logging 0.5.3 → 0.6.0

data/lib/logging/appenders/io.rb

@@ -1,9 +1,8 @@
-# $Id: io.rb 37 2007-10-26 19:12:44Z tim_pease $
+# $Id: io.rb 72 2007-12-26 21:59:58Z tim_pease $
 
 require 'logging/appender'
 
-module Logging
-module Appenders
+module Logging::Appenders
 
   # This class provides an Appender that can write to any IO stream
   # configured for writing.
@@ -40,7 +39,9 @@ module Appenders
       super(*args)
       io, @io = @io, nil
       io.close unless [STDIN, STDERR, STDOUT].include?(io)
-      self
+    rescue IOError => err
+    ensure
+      return self
     end
 
     # call-seq:
@@ -59,22 +60,26 @@ module Appenders
     private
 
     # call-seq:
-    #    write( str )
+    #    write( event, do_layout = true )
+    #
+    # Writes the given _event_ to the IO stream. If an +IOError+ is detected,
+    # than this appender will be turned off and the error reported.
     #
-    # Writes the given string to the IO stream. If an +IOError+ is detected,
-    # than this appender will be closed and the error reported.
+    # If the _do_layout_ flag is set to +true+, then the event will be
+    # formatted using the configured layout object. If set to false, then
+    # the event will be stringiied and appended to the IO stream.
     #
-    def write( str )
+    def write( event, do_layout = true )
       begin
+        str = do_layout ? @layout.format(event) : event.to_s
         @io.print str
       rescue IOError
-        close false
+        self.level = :off
         raise
       end
     end
 
   end  # class IO
-end  # module Appenders
-end  # module Logging
+end  # module Logging::Appenders
 
 # EOF

data/lib/logging/appenders/rolling_file.rb

@@ -1,6 +1,7 @@
-# $Id: rolling_file.rb 37 2007-10-26 19:12:44Z tim_pease $
+# $Id: rolling_file.rb 67 2007-12-26 16:27:06Z tim_pease $
 
 require 'logging/appenders/file'
+require 'lockfile'
 
 module Logging::Appenders
 
@@ -28,7 +29,7 @@ module Logging::Appenders
   # 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
+  class RollingFile < ::Logging::Appenders::IO
 
     # call-seq:
     #    RollingFile.new( name, opts )
@@ -52,11 +53,16 @@ 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)
     #
     def initialize( name, opts = {} )
       # raise an error if a filename was not given
-      @fn = opts[:filename] || opts['filename']
+      @fn = opts.getopt(:filename, name)
       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)
@@ -65,21 +71,21 @@ module Logging::Appenders
       @glob = "#{bn}.*#{ext}"
       @logname_fmt = "#{bn}.%d#{ext}"
 
-      @keep = opts.delete(:keep) || opts.delete('keep')
-      @keep = Integer(@keep) unless @keep.nil?
+      # grab our options
+      @keep = opts.getopt(:keep, :as => Integer)
+      @size = opts.getopt(:size, :as => Integer)
 
-      # 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
-      @size = opts.delete(:size) || opts.delete('size')
-      @size = Integer(@size) unless @size.nil?
+      @lockfile = if opts.getopt(:safe, false) and !(%r/win32/ =~ RUBY_PLATFORM)
+        Lockfile.new(
+            @fn + '.lck',
+            :retries => 1,
+            :timeout => 2
+        )
+      end
 
       code = 'def sufficiently_aged?() false end'
 
-      @age = opts.delete(:age) || opts.delete('age')
-      case @age
+      case @age = opts.getopt(:age)
       when 'daily'
         @start_time = Time.now
         code = <<-CODE
@@ -133,25 +139,45 @@ module Logging::Appenders
       meta = class << self; self end
       meta.class_eval code
 
-      @file_size = (::File.exist?(@fn) ? ::File.size(@fn) : 0)
-      super(name, opts)
+      # if the truncate flag was set to true, then roll 
+      roll_now = opts.getopt(:truncate, false)
+      roll_files if roll_now
+
+      super(name, open_logfile, opts)
     end
 
 
     private
 
     # call-seq:
-    #    write( str )
+    #    write( event, do_layout = true )
     #
-    # Write the given string to the log file. The log file will be rolled
+    # 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 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
+    # If the _do_layout_ flag is set to +true+, then the event will be
+    # formatted using the configured layout object. If set to false, then
+    # the event will be stringiied and appended to the current log file.
+    #
+    def write( event, do_layout = true )
+      check_logfile
+
+      str = do_layout ? @layout.format(event) : event.to_s
+      super(str, false)
+
+      if roll_required?(str)
+        return roll unless @lockfile
+
+        begin
+          @lockfile.lock
+          check_logfile
+          roll if roll_required?
+        ensure
+          @lockfile.unlock
+        end
+      end
+    end
 
     # call-seq:
     #    roll
@@ -160,25 +186,28 @@ module Logging::Appenders
     # new log file.
     #
     def roll
-      begin; @io.close; rescue; end
+      @io.close rescue nil
       roll_files
-      @io = ::File.new(@fn, 'a')
+      open_logfile
     end
 
     # call-seq:
-    #    roll_required?
+    #    roll_required?( str )    => true or false
     #
     # Returns +true+ if the log file needs to be rolled.
     #
-    def roll_required?
+    def roll_required?( str = nil )
       # check if max size has been exceeded
-      if @size and @file_size > @size
-        @file_size = 0
-        return true
+      s = if @size 
+        @file_size = @stat.size if @stat.size > @file_size
+        @file_size += str.size if str
+        @file_size > @size
       end
 
       # check if max age has been exceeded
-      return sufficiently_aged?
+      a = sufficiently_aged?
+
+      return (s || a)
     end
 
     # call-seq:
@@ -227,6 +256,40 @@ module Logging::Appenders
       ::File.rename(@fn, sprintf(@logname_fmt, 1))
     end
 
+    # 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
+
+      @stat = ::File.stat(@fn)
+      @file_size = @stat.size
+      @inode = @stat.ino
+
+      return @io
+    end
+
+    #
+    #
+    def check_logfile
+      retry_cnt ||= 0
+
+      @stat = ::File.stat(@fn)
+      return unless @lockfile
+      return if @inode == @stat.ino
+
+      @io.close rescue nil
+      open_logfile
+    rescue SystemCallError
+      raise if retry_cnt > 3
+      retry_cnt += 1
+      sleep 0.08
+      retry
+    end
+
   end  # class RollingFile
 end  # module Logging::Appenders
 

data/lib/logging/appenders/syslog.rb

@@ -1,4 +1,4 @@
-# $Id: syslog.rb 52 2007-11-27 23:53:23Z tim_pease $
+# $Id: syslog.rb 72 2007-12-26 21:59:58Z tim_pease $
 
 begin
   require 'logging/appender'
@@ -13,8 +13,7 @@ end
 #
 if HAVE_SYSLOG
 
-module Logging
-module Appenders
+module Logging::Appenders
 
   # This class provides an Appender that can write to the UNIX syslog
   # daemon.
@@ -96,20 +95,19 @@ module Appenders
     #                  through LOG_LOCAL7.
     #
     def initialize( name, opts = {} )
-      super
-
-      ident = opts[:ident] || opts['ident'] || name
-      logopt = opts[:logopt] || opts['logopt'] || (LOG_PID | LOG_CONS)
-      facility = opts[:facility] || opts['facility'] || LOG_USER
-      @syslog = ::Syslog.open(ident, Integer(logopt), Integer(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
       @map = [LOG_DEBUG, LOG_INFO, LOG_WARNING, LOG_ERR, LOG_CRIT]
 
-      if opts.has_key?('map') or opts.has_key?(:map)
-        self.map = opts[:map] || opts['map']
-      end
+      map = opts.getopt(:map)
+      self.map = map unless map.nil?
+
+      super
     end
 
     # call-seq:
@@ -140,8 +138,10 @@ module Appenders
     #
     # Closes the connetion to the syslog facility.
     #
-    def close
+    def close( footer = true )
+      super
       @syslog.close
+      self
     end
 
     # call-seq:
@@ -154,47 +154,35 @@ module Appenders
       !@syslog.opened?
     end
 
-    # call-seq:
-    #    append( event )
-    #
-    # Write the given _event_ to the syslog facility. The log event will be
-    # processed through the Layout assciated with this appender. The message
-    # will be logged at the level specified by the event.
-    #
-    def append( event )
-      if closed?
-        raise RuntimeError,
-              "appender '<#{self.class.name}: #{@name}>' is closed"
-      end
 
-      sync do
-        msg = @layout.format(event)
-        pri = @map[event.level]
-        @syslog.log(pri, '%s', msg)
-      end unless @level > event.level
-      self
-    end
+    private
 
     # call-seq:
-    #    syslog << string
+    #    write( event, do_layout = true )
+    #
+    # Write the given _event_ to the syslog facility. The log event will be
+    # processed through the Layout assciated with this appender if the
+    # _do_layout_ flag is set to +true+. The message will be logged at the
+    # level specified by the event.
     #
-    # Write the given _string_ to the syslog facility "as is" -- no
+    # If the _do_layout_ flag is set to +false+, the _event_ will be
+    # converted to a string and wirtten to the syslog facility "as is" -- no
     # layout formatting will be performed. The string will be logged at the
     # LOG_DEBUG level of the syslog facility.
     #
-    def <<( str )
-      if closed?
-        raise RuntimeError,
-              "appender '<#{self.class.name}: #{@name}>' is closed"
-      end
+    def write( event, do_layout = true )
+      pri = LOG_DEBUG
+      msg = if do_layout
+          pri = @map[event.level]
+          @layout.format(event)
+        else
+          event.to_s
+        end
 
-      sync {@syslog.log(LOG_DEBUG, '%s', str)}
+      @syslog.log(pri, '%s', msg)
       self
     end
 
-
-    private
-
     # call-seq:
     #    syslog_level_num( level )    => integer
     #
@@ -214,9 +202,7 @@ module Appenders
 
   end  # class Syslog
 
-end  # module Appenders
-end  # module Logging
-
+end  # module Logging::Appenders
 end  # HAVE_SYSLOG
 
 # EOF

data/lib/logging/layout.rb

@@ -1,4 +1,4 @@
-# $Id: layout.rb 52 2007-11-27 23:53:23Z tim_pease $
+# $Id: layout.rb 62 2007-12-22 20:37:05Z tim_pease $
  
 require 'yaml'
 require 'logging'
@@ -32,8 +32,10 @@ module Logging
     # then <tt>:string</tt> is used.
     #
     def initialize( opts = {} )
-      f = opts[:format_as] || opts['format_as']
-      f ||= ::Logging::OBJ_FORMAT if ::Logging.const_defined? 'OBJ_FORMAT'
+      default = ::Logging.const_defined?('OBJ_FORMAT') ?
+                ::Logging::OBJ_FORMAT : nil
+
+      f = opts.getopt(:format_as, default)
       f = f.intern if f.instance_of? String
 
       @obj_format = case f

data/lib/logging/layouts/pattern.rb

@@ -1,4 +1,4 @@
-# $Id: pattern.rb 52 2007-11-27 23:53:23Z tim_pease $
+# $Id: pattern.rb 62 2007-12-22 20:37:05Z tim_pease $
 
 require 'logging'
 require 'logging/layout'
@@ -227,13 +227,13 @@ module Layouts
       super
       @created_at = Time.now
 
-      @pattern = opts[:pattern] || opts['pattern']
-      @date_pattern = opts[:date_pattern] || opts['date_pattern']
-      @date_method = opts[:date_method] || opts['date_method']
-
-      @pattern ||= "[%d] %-#{::Logging::MAX_LEVEL_LENGTH}l -- %c : %m\n"
+      @date_pattern = opts.getopt(:date_pattern)
+      @date_method = opts.getopt(:date_method)
       @date_pattern = ISO8601 if @date_pattern.nil? and @date_method.nil?
 
+      @pattern = opts.getopt(:pattern,
+          "[%d] %-#{::Logging::MAX_LEVEL_LENGTH}l -- %c : %m\n")
+
       Pattern.create_date_format_methods(self)
       Pattern.create_format_method(self)
     end

data/lib/logging/utils.rb

@@ -0,0 +1,44 @@
+# $Id: utils.rb 65 2007-12-23 04:48:55Z tim_pease $
+
+class Hash
+
+  # call-seq:
+  #    getopt( key, default = nil, :as => class )
+  #
+  # Returns the value associated with the _key_. If the has does not contain
+  # the _key_, then the _default_ value is returned.
+  #
+  # Optionally, the value can be converted into to an instance of the given
+  # _class_. The supported classes are:
+  #
+  #     Integer
+  #     Float
+  #     Array
+  #     String
+  #     Symbol
+  #
+  # If the value is +nil+, then no converstion will be performed.
+  #
+  def getopt( *args )
+    opts = Hash === args.last ? args.pop : {}
+    key, default = args
+
+    val = if has_key?(key);                self[key]
+          elsif has_key?(key.to_s);        self[key.to_s]
+          elsif has_key?(key.to_s.intern); self[key.to_s.intern]
+          else default end
+
+    return if val.nil?
+    return val unless opts.has_key?(:as)
+
+    case opts[:as].name.intern
+    when :Integer; Integer(val)
+    when :Float;   Float(val)
+    when :Array;   Array(val)
+    when :String;  String(val)
+    when :Symbol;  String(val).intern
+    else val end
+  end
+end
+
+# EOF