logging 0.1.0 → 0.2.0

data/examples/logging.yaml

@@ -0,0 +1,63 @@
+
+purpose    : TestA
+description: This is the 1st YAML doc
+say        : Hi
+
+---
+# *** YAML2LOGGING ***
+logging_config:
+  # define all pre config ...
+  pre_config:
+    define_levels:
+      - DEB
+      - INF
+      - PRT
+      - WRN
+      - ERR
+      - FAT
+    format_as   : inspect
+    root:
+      level     : WRN
+
+  # define all loggers ...
+  loggers:
+    - name      : mylogger
+      level     : DEB
+      additive  : false
+      trace     : false      
+      appenders:
+        - stderr
+        - logfile 
+
+    - name      : yourlogger
+      level     : INF 
+      appenders: 
+        - stderr
+        - logfile 
+
+  # define all appenders (incl. layouts)      
+  appenders:
+    - type          : Stderr
+      name          : stderr 
+      level         : DEB
+      layout:
+        type        : Basic
+        format_as   : string
+
+    - type          : File
+      name          : logfile
+      level         : DEB
+      filename      : 'temp.log'
+      truncate      : true
+      layout:
+        type        : Pattern
+        date_method : to_s
+        pattern     : '[%d] %l  %c : %m\n'
+  
+---
+purpose    : TestB
+description: This is the last YAML doc
+say        : Bye
+
+
+# EOF  

data/lib/logging.rb

@@ -1,16 +1,20 @@
-# $Id: logging.rb 12 2007-01-14 20:03:40Z tim_pease $
+# $Id: logging.rb 22 2007-01-29 16:20:54Z tim_pease $
 
 require 'logging/repository'
 
 # require all appenders
 require 'logging/appenders/console'
 require 'logging/appenders/file'
+require 'logging/appenders/rolling_file'
 require 'logging/appenders/static_appender'
 
 # require all layouts
 require 'logging/layouts/basic'
 require 'logging/layouts/pattern'
 
+# require all configurators
+require 'logging/config/yaml_configurator'
+
 
 #
 #
@@ -21,6 +25,21 @@ module Logging
   LNAMES = {}  # :nodoc:
 
   class << self
+    #
+    # call-seq:
+    #    Logging.configure( filename )
+    #
+    # Configures the Logging framework using the configuration information
+    # found in the given file. The file extension should be either '.yaml'
+    # or '.yml' (XML configuration is not yet supported).
+    #
+    def configure( filename )
+      case File.extname(filename)
+      when '.yaml', '.yml':
+        ::Logging::Config::YamlConfigurator.load(filename)
+      else raise ArgumentError, 'unknown configuration file format' end
+    end
+
     #
     # call-seq:
     #    define_levels( levels )
@@ -99,6 +118,8 @@ module Logging
     # +:inspect+, +:yaml+ is passed to this method.
     #
     def format_as( f )
+      f = f.intern if f.instance_of? String
+
       unless [:string, :inspect, :yaml].include? f
         raise ArgumentError, "unknown object format '#{f}'"
       end
@@ -119,7 +140,7 @@ module Logging
       case l
       when 'all': 0
       when 'off': LEVELS.length
-      else LEVELS[l] end
+      else begin; Integer(l); rescue ArgumentError; LEVELS[l] end end
     end
     # :startdoc:
   end

data/lib/logging/appender.rb

@@ -1,6 +1,6 @@
-# $Id: appender.rb 12 2007-01-14 20:03:40Z tim_pease $
+# $Id: appender.rb 20 2007-01-26 20:18:42Z tim_pease $
 
-require 'sync'
+require 'thread'
 require 'logging'
 require 'logging/logger'
 require 'logging/layout'
@@ -39,11 +39,14 @@ module Logging
     def initialize( name, opts = {} )
       @name = name.to_s
       @closed = false
-      @level = 0
-      self.layout = opts[:layout] if opts.include? :layout
+
+      layout = opts[:layout] || opts['layout']
+      self.layout = layout unless layout.nil?
       @layout ||= ::Logging::Layouts::Basic.new
 
-      @sync = Sync.new
+      self.level = opts[:level] || opts['level']
+
+      @mutex = Mutex.new
       sync {write(@layout.header)}
 
       ::Logging::Appender[@name] = self
@@ -195,8 +198,7 @@ module Logging
     # can call +sync+ multiple times without hanging the thread.
     #
     def sync
-      if Thread.current == @sync.sync_ex_locker then yield
-      else @sync.synchronize(:EX) {yield} end
+      @mutex.synchronize {yield}
     end
 
   end  # class Appender

data/lib/logging/appenders/console.rb

@@ -1,4 +1,4 @@
-# $Id: console.rb 2 2007-01-09 18:10:50Z tim_pease $
+# $Id: console.rb 17 2007-01-20 18:47:43Z tim_pease $
 
 require 'logging/appenders/io'
 
@@ -8,7 +8,7 @@ module Appenders
   #
   # This class provides an Appender that can write to STDOUT.
   #
-  class StdOut< ::Logging::Appenders::IO
+  class Stdout< ::Logging::Appenders::IO
 
     #
     # call-seq:
@@ -18,15 +18,17 @@ module Appenders
     # Creates a new StdOut Appender. The name 'stdout' will always be used for
     # this appender.
     #
-    def initialize( opts = {} )
-      super('stdout', STDOUT, opts)
+    def initialize( name = nil, opts = {} )
+      name ||= 'stdout'
+      STDOUT.sync = true
+      super(name, STDOUT, opts)
     end
-  end  # class StdOut
+  end  # class Stdout
 
   #
   # This class provides an Appender that can write to STDERR.
   #
-  class StdErr< ::Logging::Appenders::IO
+  class Stderr< ::Logging::Appenders::IO
 
     #
     # call-seq:
@@ -36,10 +38,12 @@ module Appenders
     # Creates a new StdErr Appender. The name 'stderr' will always be used for
     # this appender.
     #
-    def initialize( opts = {} )
-      super('stderr', STDERR, opts)
+    def initialize( name = nil, opts = {} )
+      name ||= 'stderr'
+      STDERR.sync = true
+      super(name, STDERR, opts)
     end
-  end  # class StdErr
+  end  # class Stderr
 
 end  # module Appenders
 end  # module Logging

data/lib/logging/appenders/file.rb

@@ -1,9 +1,8 @@
-# $Id: file.rb 2 2007-01-09 18:10:50Z tim_pease $
+# $Id: file.rb 22 2007-01-29 16:20:54Z tim_pease $
 
 require 'logging/appenders/io'
 
-module Logging
-module Appenders
+module Logging::Appenders
 
   #
   # This class provides an Appender that can write to a File.
@@ -12,34 +11,37 @@ module Appenders
 
     #
     # call-seq:
-    #    File.new( filename )
-    #    File.new( filename, :truncate => true )
-    #    File.new( filename, :layout => layout )
+    #    File.new( name, :filename => 'file' )
+    #    File.new( name, :filename => 'file', :truncate => true )
+    #    File.new( name, :filename => 'file', :layout => layout )
     #
-    # Creates a new File Appender that will use the given _filename_ as the
+    # Creates a new File Appender that will use the given filename as the
     # logging destination. If the file does not already exist it will be
-    # created. If the :truncate option is set to +true+ then the file will be
-    # truncated before writing begins; otherwise, log messages will be appened
-    # to the file.
+    # created. If the :truncate option is set to +true+ then the file will
+    # be truncated before writing begins; otherwise, log messages will be
+    # appened to the file.
     #
-    def initialize( filename, opts = {} )
-      mode = opts.delete(:truncate) ? 'w' : 'a'
-
-      if ::File.exist?(filename)
-        if not ::File.file?(filename)
-          raise StandardError, "#{filename} is not a regular file"
-        elsif not ::File.writable?(filename)
-          raise StandardError, "#{filename} is not writeable"
+    def initialize( name, opts = {} )
+      @fn = opts.delete(:filename) || opts.delete('filename')
+      raise ArgumentError, 'no filename was given' if @fn.nil?
+
+      mode = opts.delete(:truncate) || opts.delete('truncate')
+      mode = mode ? 'w' : 'a'
+
+      if ::File.exist?(@fn)
+        if not ::File.file?(@fn)
+          raise StandardError, "#{@fn} is not a regular file"
+        elsif not ::File.writable?(@fn)
+          raise StandardError, "#{@fn} is not writeable"
         end
-      elsif not ::File.writable?(::File.dirname(filename))
-        raise StandardError, "#{::File.dirname(filename)} is not writable"
+      elsif not ::File.writable?(::File.dirname(@fn))
+        raise StandardError, "#{::File.dirname(@fn)} is not writable"
       end
 
-      super(filename, ::File.new(filename, mode), opts)
+      super(name, ::File.new(@fn, mode), opts)
     end
 
   end  # class FileAppender
-end  # module Appenders
-end  # module Logging
+end  # module Logging::Appenders
 
 # EOF

data/lib/logging/appenders/io.rb

@@ -1,4 +1,4 @@
-# $Id: io.rb 10 2007-01-12 18:57:07Z tim_pease $
+# $Id: io.rb 21 2007-01-26 20:23:32Z tim_pease $
 
 require 'logging/appender'
 
@@ -25,8 +25,6 @@ module Appenders
       end
 
       @io = io
-      @io.sync = true
-
       super(name, opts)
     end
 
@@ -41,11 +39,9 @@ module Appenders
     #
     def close( *args )
       return self if @io.nil?
-      sync do
-        super(*args)
-        @io.close unless [STDIN, STDERR, STDOUT].include?(@io)
-        @io = nil
-      end
+      super(*args)
+      io, @io = @io, nil
+      io.close unless [STDIN, STDERR, STDOUT].include?(io)
       self
     end
 

data/lib/logging/appenders/rolling_file.rb

@@ -0,0 +1,189 @@
+# $Id: rolling_file.rb 22 2007-01-29 16:20:54Z tim_pease $
+
+require 'logging/appenders/file'
+
+module Logging::Appenders
+
+  #
+  # An appender that writes to a file and ensures that the file size or age
+  # 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.
+  #
+  # 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
+  # file has no extension then the number is appended to the filename. Here
+  # is a simple example:
+  #
+  #    /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.
+  #
+  # The actual process of rolling all the log file names can be expensive if
+  # there are many, many older log files to process.
+  #
+  class RollingFile < ::Logging::Appenders::File
+
+    #
+    # call-seq:
+    #    RollingFile.new( name, opts )
+    #
+    # Creates a new Rolling File Appender. The _name_ is the unique Appender
+    # name used to retrieve this appender from the Appender hash. The only
+    # required option is the filename to use for creating log files.
+    #
+    #  [:filename]  The base filename to use when constructing new log
+    #               filenames.
+    #
+    # The following options are optional:
+    #
+    #  [:layout]    The Layout that will be used by this appender. The Basic
+    #               layout will be used if none is given.
+    #  [:truncate]  When set to true any existing log files will be rolled
+    #               immediately and a new, empty log file will be created.
+    #  [:max_size]  The maximum allowed size (in bytes) of a log file before
+    #               it is rolled.
+    #  [:max_age]   The maximum age (in seconds) of a log file before it is
+    #               rolled.
+    #  [:keep]      The number of rolled log files to keep.
+    #
+    def initialize( name, opts = {} )
+      # raise an error if a filename was not given
+      @fn = opts[:filename] || opts['filename']
+      raise ArgumentError, 'no filename was given' if @fn.nil?
+
+      # 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}"
+
+      # if the truncate flag was set to true, then roll 
+      roll_now = opts.delete(:truncate) || opts.delete('truncate')
+      roll_files if roll_now
+
+      # grab out our options
+      @keep = opts.delete(:keep) || opts.delete('keep')
+      @max_size = opts.delete(:max_size) || opts.delete('max_size')
+      @max_age = opts.delete(:max_age) || opts.delete('max_age')
+
+      @keep = Integer(@keep) unless @keep.nil?
+      @max_size = Integer(@max_size) unless @max_size.nil?
+      unless @max_age.nil?
+        @max_age = Integer(@max_age)
+        @start_time = Time.now
+      end
+
+      @file_size = (::File.exist?(@fn) ? ::File.size(@fn) : 0)
+      super(name, opts)
+    end
+
+    private
+    #
+    # call-seq:
+    #    write( str )
+    #
+    # Write the given string 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 write( str )
+      super
+      @file_size += str.size  # keep track of the size internally since
+      roll if roll_required?  # the file IO stream is probably not being 
+    end                       # flushed to disk immediately
+
+    #
+    # call-seq:
+    #    roll
+    #
+    # Close the currently open log file, roll all the log files, and open a
+    # new log file.
+    #
+    def roll
+      begin; @io.close; rescue; end
+      roll_files
+      @io = ::File.new(@fn, 'w')
+    end
+
+    #
+    # call-seq:
+    #    roll_required?
+    #
+    # Returns +true+ if the log file needs to be rolled.
+    #
+    def roll_required?
+      # check if max size has been exceeded
+      if @max_size and @file_size > @max_size
+        @file_size = 0
+        return true
+      end
+
+      # check if max age has been exceeded
+      if @max_age and (Time.now - @start_time) > @max_age
+        @start_time = Time.now
+        return true
+      end
+
+      false
+    end
+
+    #
+    # call-seq:
+    #    roll_files
+    #
+    # 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
+      return unless ::File.exist?(@fn)
+
+      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
+      end
+
+      # finally reanme the base log file
+      ::File.rename(@fn, sprintf(@logname_fmt, 1))
+    end
+
+  end  # class RollingFile
+end  # module Logging::Appenders
+
+# EOF