logging 1.8.2 → 2.0.0

data/lib/logging/appender.rb

@@ -16,7 +16,7 @@ module Logging
 #
 class Appender
 
-  attr_reader :name, :layout, :level
+  attr_reader :name, :layout, :level, :filters
 
   # call-seq:
   #    Appender.new( name )
@@ -32,27 +32,29 @@ class Appender
   #    :layout   => the layout to use when formatting log events
   #    :level    => the level at which to log
   #    :encoding => encoding to use when writing messages (defaults to UTF-8)
+  #    :filters  => filters to apply to events before processing
   #
   def initialize( name, opts = {} )
     ::Logging.init unless ::Logging.initialized?
 
-    @name = name.to_s
-    @closed = false
+    @name    = name.to_s
+    @closed  = false
+    @filters = []
+    @mutex   = ReentrantMutex.new
 
-    self.layout = opts.getopt(:layout, ::Logging::Layouts::Basic.new)
-    self.level = opts.getopt(:level)
+    self.layout   = opts.fetch(:layout, ::Logging::Layouts::Basic.new)
+    self.level    = opts.fetch(:level, nil)
     self.encoding = opts.fetch(:encoding, self.encoding)
+    self.filters  = opts.fetch(:filters, nil)
 
-    @mutex = ReentrantMutex.new
-
-    if opts.getopt(:header, true)
+    if opts.fetch(:header, true)
       header = @layout.header
 
       unless header.nil? || header.empty?
         begin
           write(header)
         rescue StandardError => err
-          ::Logging.log_internal(-2) {err}
+          ::Logging.log_internal_error(err)
         end
       end
     end
@@ -73,12 +75,12 @@ class Appender
     end
 
     # only append if the event level is less than or equal to the configured
-    # appender level
-    unless @level > event.level
+    # appender level and the filter does not disallow it
+    if event = allow(event)
       begin
         write(event)
       rescue StandardError => err
-        ::Logging.log_internal(-2) {err}
+        ::Logging.log_internal_error(err)
       end
     end
 
@@ -97,11 +99,11 @@ class Appender
             "appender '<#{self.class.name}: #{@name}>' is closed"
     end
 
-    unless @level >= ::Logging::LEVELS.length
+    unless off?
       begin
         write(str)
       rescue StandardError => err
-        ::Logging.log_internal(-2) {err}
+        ::Logging.log_internal_error(err)
       end
     end
     self
@@ -162,6 +164,35 @@ class Appender
     @layout = layout
   end
 
+  # Sets the filter(s) to be used by this appender. This method will clear the
+  # current filter set and add those passed to this setter method.
+  #
+  # Examples
+  #    appender.filters = Logging::Filters::Level.new(:warn, :error)
+  #
+  def filters=( args )
+    @filters.clear
+    add_filters(*args)
+  end
+
+  # Sets the filter(s) to be used by this appender. The filters will be
+  # applied in the order that they are added to the appender.
+  #
+  # Examples
+  #    add_filters(Logging::Filters::Level.new(:warn, :error))
+  #
+  # Returns this appender instance.
+  def add_filters( *args )
+    args.flatten.each do |filter|
+      next if filter.nil?
+      unless filter.kind_of?(::Logging::Filter)
+        raise TypeError, "#{filter.inspect} is not a kind of 'Logging::Filter'"
+      end
+      @filters << filter
+    end
+    self
+  end
+
   # call-seq:
   #    close( footer = true )
   #
@@ -183,7 +214,7 @@ class Appender
         begin
           write(footer)
         rescue StandardError => err
-          ::Logging.log_internal(-2) {err}
+          ::Logging.log_internal_error(err)
         end
       end
     end
@@ -250,7 +281,6 @@ class Appender
   # value - The encoding as a String, Symbol, or Encoding instance.
   #
   # Raises ArgumentError if the value is not a valid encoding.
-  #
   def encoding=( value )
     if value.nil?
       @encoding = nil
@@ -259,6 +289,31 @@ class Appender
     end
   end
 
+  # Check to see if the event should be processed by the appender. An event will
+  # be rejected if the event level is lower than the configured level for the
+  # appender. Or it will be rejected if one of the filters rejects the event.
+  #
+  # event - The LogEvent to check
+  #
+  # Returns the event if it is allowed; returns `nil` if it is not allowed.
+  def allow( event )
+    return nil if @level > event.level
+    @filters.each do |filter|
+      break unless event = filter.allow(event)
+    end
+    event
+  end
+
+  # Returns `true` if the appender has been turned off. This is useful for
+  # appenders that write data to a remote location (such as syslog or email),
+  # and that write encounters too many errors. The appender can turn itself off
+  # to and log an error via the `Logging` logger.
+  #
+  # Set the appender's level to a valid value to turn it back on.
+  def off?
+    @level >= ::Logging::LEVELS.length
+  end
+
 
 private
 

data/lib/logging/appenders.rb

@@ -54,9 +54,7 @@ module Logging
   require libpath('logging/appenders/buffering')
   require libpath('logging/appenders/io')
   require libpath('logging/appenders/console')
-  require libpath('logging/appenders/email')
   require libpath('logging/appenders/file')
-  require libpath('logging/appenders/growl')
   require libpath('logging/appenders/rolling_file')
   require libpath('logging/appenders/string_io')
   require libpath('logging/appenders/syslog')

data/lib/logging/appenders/buffering.rb

@@ -14,23 +14,24 @@ module Logging::Appenders
   module Buffering
 
     # Default buffer size
-    #
     DEFAULT_BUFFER_SIZE = 500;
 
     # The buffer holding the log messages
-    #
     attr_reader :buffer
 
     # The auto-flushing setting. When the buffer reaches this size, all
     # messages will be be flushed automatically.
-    #
     attr_reader :auto_flushing
 
     # When set, the buffer will be flushed at regular intervals defined by the
     # flush_period.
-    #
     attr_reader :flush_period
 
+    # Messages will be written in chunks. This controls the number of messages
+    # to pull from the buffer for each write operation. The default is to pull
+    # all messages from the buffer at once.
+    attr_accessor :write_size
+
     # Setup the message buffer and other variables for automatically and
     # periodically flushing the buffer.
     #
@@ -67,22 +68,36 @@ module Logging::Appenders
       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.
-    #
+    # Call `flush` to force an appender to write out any buffered log events.
+    # Similar to `IO#flush`, so use in a similar fashion.
     def flush
       return self if @buffer.empty?
 
-      str = nil
+      ary = nil
       sync {
-        str = @buffer.join
+        ary = @buffer.dup
         @buffer.clear
       }
 
-      canonical_write str unless str.empty?
+      if ary.length <= write_size
+        str = ary.join
+        canonical_write str unless str.empty?
+      else
+        ary.each_slice(write_size) do |a|
+          str = a.join
+          canonical_write str unless str.empty?
+        end
+      end
+
       self
     end
 
+    # Clear the underlying buffer of all log events. These events will not be
+    # appended to the logging destination; they will be lost.
+    def clear!
+      sync { @buffer.clear }
+    end
+
     # 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
@@ -154,7 +169,7 @@ module Logging::Appenders
           "auto_flushing period must be greater than zero: #{period.inspect}"
       end
 
-      @auto_flushing = DEFAULT_BUFFER_SIZE if @flush_period and @auto_flushing <= 1
+      @auto_flushing = DEFAULT_BUFFER_SIZE if @flush_period && @auto_flushing <= 1
     end
 
     # Configure periodic flushing of the message buffer. Periodic flushing is
@@ -205,9 +220,10 @@ module Logging::Appenders
     def configure_buffering( opts )
       ::Logging.init unless ::Logging.initialized?
 
-      self.immediate_at = opts.getopt(:immediate_at, '')
-      self.auto_flushing = opts.getopt(:auto_flushing, true)
-      self.flush_period = opts.getopt(:flush_period, nil)
+      self.immediate_at  = opts.fetch(:immediate_at, '')
+      self.auto_flushing = opts.fetch(:auto_flushing, true)
+      self.flush_period  = opts.fetch(:flush_period, nil)
+      self.write_size    = opts.fetch(:write_size, DEFAULT_BUFFER_SIZE)
     end
 
     # Returns true if the _event_ level matches one of the configured
@@ -241,7 +257,7 @@ module Logging::Appenders
         canonical_write(str)
       else
         sync {
-          str = str.force_encoding(encoding) if encoding and str.encoding != encoding
+          str = str.force_encoding(encoding) if encoding && str.encoding != encoding
           @buffer << str
         }
         @periodic_flusher.signal if @periodic_flusher
@@ -333,7 +349,7 @@ module Logging::Appenders
             @appender.flush
           rescue => err
             ::Logging.log_internal {"PeriodicFlusher for appender #{@appender.inspect} encountered an error"}
-            ::Logging.log_internal(-2) {err}
+            ::Logging.log_internal_error(err)
           end
         }; @thread = nil }
 

data/lib/logging/appenders/file.rb

@@ -47,12 +47,12 @@ module Logging::Appenders
     # appended to the file.
     #
     def initialize( name, opts = {} )
-      @fn = opts.getopt(:filename, name)
+      @fn = opts.fetch(:filename, name)
       raise ArgumentError, 'no filename was given' if @fn.nil?
 
       @fn = ::File.expand_path(@fn)
       self.class.assert_valid_logfile(@fn)
-      @mode = opts.getopt(:truncate) ? 'w' : 'a'
+      @mode = opts.fetch(:truncate, false) ? 'w' : 'a'
 
       self.encoding = opts.fetch(:encoding, self.encoding)
       @mode = "#{@mode}:#{self.encoding}" if self.encoding

data/lib/logging/appenders/io.rb

@@ -76,7 +76,7 @@ module Logging::Appenders
     rescue StandardError => err
       self.level = :off
       ::Logging.log_internal {"appender #{name.inspect} has been disabled"}
-      ::Logging.log_internal(-2) {err}
+      ::Logging.log_internal_error(err)
     end
 
   end  # IO

data/lib/logging/appenders/rolling_file.rb

@@ -1,8 +1,6 @@
-
 module Logging::Appenders
 
   # Accessor / Factory for the RollingFile appender.
-  #
   def self.rolling_file( *args )
     return ::Logging::Appenders::RollingFile if args.empty?
     ::Logging::Appenders::RollingFile.new(*args)
@@ -23,10 +21,9 @@ module Logging::Appenders
   #    /var/log/ruby.log   =>   /var/log/ruby.1.log
   #
   # 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.
+  # (`/var/log/ruby.log` 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.
@@ -38,14 +35,13 @@ module Logging::Appenders
   #
   #    /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.
+  # Where the date is expressed as `%Y%m%d` 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:
@@ -58,6 +54,20 @@ module Logging::Appenders
     #  [:filename]  The base filename to use when constructing new log
     #               filenames.
     #
+    # The "rolling" portion of the filename can be configured via some simple
+    # pattern templates. For numbered rolling, you can use {{.%d}}
+    #
+    #   "logname{{.%d}}.log" => ["logname.log", "logname.1.log", "logname.2.log" ...]
+    #   "logname.log{{-%d}}" => ["logname.log", "logname.log-1", "logname.log-2" ...]
+    #
+    # And for date rolling you can use `strftime` patterns:
+    #
+    #   "logname{{.%Y%m%d}}.log"            => ["logname.log, "logname.20130626.log" ...]
+    #   "logname{{.%Y-%m-%dT%H:%M:%S}}.log" => ["logname.log, "logname.2013-06-26T22:03:31.log" ...]
+    #
+    # If the defaults suit you fine, just pass in the :roll_by option and use
+    # your normal log filename without any pattern template.
+    #
     # The following options are optional:
     #
     #  [:layout]    The Layout that will be used by this appender. The Basic
@@ -74,90 +84,27 @@ module Logging::Appenders
     #               'date'.
     #
     def initialize( name, opts = {} )
-      # raise an error if a filename was not given
-      @fn = opts.getopt(:filename, name)
-      raise ArgumentError, 'no filename was given' if @fn.nil?
-
-      @fn = ::File.expand_path(@fn)
-      @fn_copy = @fn + '._copy_'
-      ::Logging::Appenders::File.assert_valid_logfile(@fn)
+      @roller = Roller.new name, opts
 
       # grab our options
-      @size = opts.getopt(:size, :as => Integer)
+      @size = opts.fetch(:size, nil)
+      @size = Integer(@size) unless @size.nil?
 
-      code = 'def sufficiently_aged?() false end'
-      @age_fn = @fn + '.age'
+      @age_fn = filename + '.age'
       @age_fn_mtime = nil
+      @age = opts.fetch(:age, nil)
 
-      case @age = opts.getopt(:age)
-      when 'daily'
-        code = <<-CODE
-        def sufficiently_aged?
-          @age_fn_mtime ||= ::File.mtime(@age_fn)
-          now = Time.now
-          if (now.day != @age_fn_mtime.day) or (now - @age_fn_mtime) > 86400
-            return true
-          end
-          false
-        end
-        CODE
-      when 'weekly'
-        code = <<-CODE
-        def sufficiently_aged?
-          @age_fn_mtime ||= ::File.mtime(@age_fn)
-          if (Time.now - @age_fn_mtime) > 604800
-            return true
-          end
-          false
-        end
-        CODE
-      when 'monthly'
-        code = <<-CODE
-        def sufficiently_aged?
-          @age_fn_mtime ||= ::File.mtime(@age_fn)
-          now = Time.now
-          if (now.month != @age_fn_mtime.month) or (now - @age_fn_mtime) > 2678400
-            return true
-          end
-          false
-        end
-        CODE
-      when Integer, String
-        @age = Integer(@age)
-        code = <<-CODE
-        def sufficiently_aged?
-          @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__
+      # create our `sufficiently_aged?` method
+      build_singleton_methods
+      FileUtils.touch(@age_fn) if @age && !test(?f, @age_fn)
 
       # we are opening the file in read/write mode so that a shared lock can
       # be used on the file descriptor => http://pubs.opengroup.org/onlinepubs/009695399/functions/fcntl.html
       @mode = encoding ? "a+:#{encoding}" : 'a+'
-      super(name, ::File.new(@fn, @mode), 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, ::File.new(filename, @mode), opts)
 
       # if the truncate flag was set to true, then roll
-      roll_now = opts.getopt(:truncate, false)
+      roll_now = opts.fetch(:truncate, false)
       if roll_now
         copy_truncate
         @roller.roll_files
@@ -165,20 +112,20 @@ module Logging::Appenders
     end
 
     # Returns the path to the logfile.
-    #
-    def filename() @fn.dup end
+    def filename
+      @roller.filename
+    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
+        if defined?(@io) && @io
           flush
           @io.close rescue nil
         end
-        @io = ::File.new(@fn, @mode)
+        @io = ::File.new(filename, @mode)
       }
       super
       self
@@ -187,14 +134,20 @@ module Logging::Appenders
 
   private
 
+    # Returns the file name to use as the temporary copy location. We are
+    # using copy-and-truncate semantics for rolling files so that the IO
+    # file descriptor remains valid during rolling.
+    def copy_file
+      @roller.copy_file
+    end
+
     # Write the given _event_ to the log file. The log file will be rolled
     # if the maximum file size is exceeded or if the file is older than the
     # maximum age.
-    #
     def canonical_write( str )
       return self if @io.nil?
 
-      str = str.force_encoding(encoding) if encoding and str.encoding != encoding
+      str = str.force_encoding(encoding) if encoding && str.encoding != encoding
       @io.flock_sh { @io.syswrite str }
 
       if roll_required?
@@ -208,16 +161,15 @@ module Logging::Appenders
     rescue StandardError => err
       self.level = :off
       ::Logging.log_internal {"appender #{name.inspect} has been disabled"}
-      ::Logging.log_internal(-2) {err}
+      ::Logging.log_internal_error(err)
     end
 
     # Returns +true+ if the log file needs to be rolled.
-    #
     def roll_required?
-      return false if ::File.exist?(@fn_copy) and (Time.now - ::File.mtime(@fn_copy)) < 180
+      return false if ::File.exist?(copy_file) && (Time.now - ::File.mtime(copy_file)) < 180
 
       # check if max size has been exceeded
-      s = @size ? ::File.size(@fn) > @size : false
+      s = @size ? ::File.size(filename) > @size : false
 
       # check if max age has been exceeded
       a = sufficiently_aged?
@@ -228,10 +180,9 @@ module Logging::Appenders
     # 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.
-    #
     def copy_truncate
-      return unless ::File.exist?(@fn)
-      FileUtils.concat @fn, @fn_copy
+      return unless ::File.exist?(filename)
+      FileUtils.concat filename, copy_file
       @io.truncate 0
 
       # touch the age file if needed
@@ -243,96 +194,208 @@ module Logging::Appenders
       @roller.roll = true
     end
 
+    # Returns the modification time of the age file.
+    def age_fn_mtime
+      @age_fn_mtime ||= ::File.mtime(@age_fn)
+    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
+    # We use meta-programming here to define the `sufficiently_aged?` method for
+    # the rolling appender. The `sufficiently_aged?` method is responsible for
+    # determining if the current log file is older than the rolling criteria -
+    # daily, weekly, etc.
+    #
+    # Returns this rolling file appender instance
+    def build_singleton_methods
+      method =
+        case @age
+        when 'daily'
+          -> {
+            now = Time.now
+            (now.day != age_fn_mtime.day) || (now - age_fn_mtime) > 86400
+          }
+
+        when 'weekly'
+          -> { (Time.now - age_fn_mtime) > 604800 }
+
+        when 'monthly'
+          -> {
+            now = Time.now
+            (now.month != age_fn_mtime.month) || (now - age_fn_mtime) > 2678400
+          }
+
+        when Integer, String
+          @age = Integer(@age)
+          -> { (Time.now - age_fn_mtime) > @age }
 
-      def roll_files
-        return unless @roll and ::File.exist?(@fn_copy)
+        else
+          -> { false }
+        end
 
-        files = Dir.glob(@glob).find_all {|fn| @rgxp =~ fn}
-        unless files.empty?
-          # sort the files in reverse 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
+      self.define_singleton_method(:sufficiently_aged?, method)
+    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
+    # Not intended for general consumption, but the Roller class is used
+    # internally by the RollingFile appender to roll dem log files according
+    # to the user's desires.
+    class Roller
+
+      # The magic regex for finding user-defined roller patterns.
+      RGXP = %r/{{(([^%]+)?.*?)}}/
+
+      # Create a new roller. See the RollingFile#initialize documentation for
+      # the list of options.
+      #
+      # name - The appender name as a String
+      # opts - The options Hash
+      #
+      def initialize( name, opts )
+        # raise an error if a filename was not given
+        @fn = opts.fetch(:filename, name)
+        raise ArgumentError, 'no filename was given' if @fn.nil?
+
+        if (m = RGXP.match @fn)
+          @roll_by = ("#{m[2]}%d" == m[1]) ? :number : :date
+        else
+          age = opts.fetch(:age, nil)
+          size = opts.fetch(:size, nil)
+
+          @roll_by =
+              case opts.fetch(:roll_by, nil)
+              when 'number'; :number
+              when 'date'; :date
+              else
+                (age && !size) ? :date : :number
+              end
+
+          ext = ::File.extname(@fn)
+          bn  = ::File.join(::File.dirname(@fn), ::File.basename(@fn, ext))
+
+          @fn = if :date == @roll_by && %w[daily weekly monthly].include?(age)
+                  "#{bn}{{.%Y%m%d}}#{ext}"
+                elsif :date == @roll_by
+                  "#{bn}{{.%Y%m%d-%H%M%S}}#{ext}"
+                else
+                  "#{bn}{{.%d}}#{ext}"
+                end
         end
 
-        # finally rename the copied log file
-        ::File.rename(@fn_copy, sprintf(@logname_fmt, 1))
-      ensure
+        @fn = ::File.expand_path(@fn)
+        ::Logging::Appenders::File.assert_valid_logfile(filename)
+
         @roll = false
+        @keep = opts.fetch(:keep, nil)
+        @keep = Integer(keep) unless keep.nil?
       end
-    end
 
-    class DateRoller
+      attr_reader :keep, :roll_by
       attr_accessor :roll
 
-      def initialize( fn, opts )
-        @fn_copy = fn + '._copy_'
-        @roll = false
-        @keep = opts.getopt(:keep, :as => Integer)
+      # Returns the regular log file name without any roller text.
+      def filename
+        return @filename if defined? @filename
+        @filename = (@fn =~ RGXP ?  @fn.sub(RGXP, '') : @fn.dup)
+        @filename.freeze
+      end
 
-        ext = ::File.extname(fn)
-        bn = ::File.join(::File.dirname(fn), ::File.basename(fn, ext))
+      # Returns the file name to use as the temporary copy location. We are
+      # using copy-and-truncate semantics for rolling files so that the IO
+      # file descriptor remains valid during rolling.
+      def copy_file
+        return @copy_file if defined? @copy_file
+        @copy_file = filename + '._copy_'
+        @copy_file.freeze
+      end
 
-        if @keep
-          @rgxp = %r/\.(\d+)(-\d+)?#{Regexp.escape(ext)}\z/
-          @glob = "#{bn}.*#{ext}"
-        end
+      # Returns the glob pattern used to find rolled log files. We use this
+      # list for pruning older log files and doing the numbered rolling.
+      def glob
+        return @glob if defined? @glob
+        m = RGXP.match @fn
+        @glob = @fn.sub(RGXP, (m[2] ? "#{m[2]}*" : '*'))
+        @glob.freeze
+      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
+      # Returns the format String used to generate rolled file names.
+      # Depending upon the `roll_by` type (:date or :number), this String will
+      # be processed by `sprintf` or `Time#strftime`.
+      def format
+        return @format if defined? @format
+        m = RGXP.match @fn
+        @format = @fn.sub(RGXP, m[1])
+        @format.freeze
       end
 
+      # Roll the log files. This method will collect the list of rolled files
+      # and then pass that list to either `roll_by_number` or `roll_by_date`
+      # to perform the actual rolling.
+      #
+      # Returns nil
       def roll_files
-        return unless @roll and ::File.exist?(@fn_copy)
+        return unless roll && ::File.exist?(copy_file)
 
-        # rename the copied log file
-        ::File.rename(@fn_copy, Time.now.strftime(@logname_fmt))
-
-        # 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}
+        files = Dir.glob(glob)
+        files.delete copy_file
+
+        self.send "roll_by_#{roll_by}", files
+
+        nil
+      ensure
+        self.roll = false
+      end
+
+      # Roll the list of log files optionally removing older files. The "older
+      # files" are determined by extracting the number from the log file name
+      # and order by the number.
+      #
+      # files - The Array of filename Strings
+      #
+      # Returns nil
+      def roll_by_number( files )
+        @number_rgxp ||= Regexp.new(@fn.sub(RGXP, '\2(\d+)'))
+
+        # sort the files in reverse order based on their count number
+        files = files.sort do |a,b|
+                  a = Integer(@number_rgxp.match(a)[1])
+                  b = Integer(@number_rgxp.match(b)[1])
+                  b <=> a
+                end
+
+        # for each file, roll its count number one higher
+        files.each do |fn|
+          cnt = Integer(@number_rgxp.match(fn)[1])
+          if keep && cnt >= keep
+            ::File.delete fn
+            next
           end
+          ::File.rename fn, sprintf(format, cnt+1)
         end
-      ensure
-        @roll = false
+
+        # finally rename the copied log file
+        ::File.rename(copy_file, sprintf(format, 1))
       end
-    end
-    # :startdoc:
 
-  end  # RollingFile
-end  # Logging::Appenders
+      # Roll the list of log files optionally removing older files. The "older
+      # files" are determined by the mtime of the log files. So touching log
+      # files or otherwise messing with them will screw this up.
+      #
+      # files - The Array of filename Strings
+      #
+      # Returns nil
+      def roll_by_date( files )
+        length = files.length
+
+        if keep && length >= keep
+          files = files.sort do |a,b|
+                    a = ::File.mtime(a)
+                    b = ::File.mtime(b)
+                    b <=> a
+                  end
+          files.last(length-keep+1).each { |fn| ::File.delete fn }
+        end
 
+        # rename the copied log file
+        ::File.rename(copy_file, Time.now.strftime(format))
+      end
+    end
+  end
+end