redcar 0.3.1dev → 0.3.2dev

data/lib/logging/lib/logging/appenders/rolling_file.rb

@@ -1,293 +0,0 @@
-
-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::IO
-
-    # 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.
-    #  [:size]      The maximum allowed size (in bytes) of a log file before
-    #               it is rolled.
-    #  [:age]       The maximum age (in seconds) of a log file before it is
-    #               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.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)
-      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'
-
-      case @age = opts.getopt(:age)
-      when 'daily'
-        FileUtils.touch(@age_fn) unless test(?f, @age_fn)
-        code = <<-CODE
-        def sufficiently_aged?
-          now = Time.now
-          start = ::File.mtime(@age_fn)
-          if (now.day != start.day) or (now - start) > 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
-            return true
-          end
-          false
-        end
-        CODE
-      when 'monthly'
-        FileUtils.touch(@age_fn) unless test(?f, @age_fn)
-        code = <<-CODE
-        def sufficiently_aged?
-          now = Time.now
-          start = ::File.mtime(@age_fn)
-          if (now.month != start.month) or (now - start) > 2678400
-            return true
-          end
-          false
-        end
-        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
-            return true
-          end
-          false
-        end
-        CODE
-      end
-      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, open_logfile, opts)
-    end
-
-    # Returns the path to the logfile.
-    #
-    def filename() @fn.dup end
-
-
-    private
-
-    # call-seq:
-    #    write( event )
-    #
-    # 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( event )
-      str = event.instance_of?(::Logging::LogEvent) ?
-            @layout.format(event) : event.to_s
-      return if str.empty?
-
-      check_logfile
-      super(str)
-
-      if roll_required?(str)
-        return roll unless @lockfile
-
-        @lockfile.lock {
-          check_logfile
-          roll if roll_required?
-        }
-      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 )
-      # 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
-
-      # check if max age has been exceeded
-      a = sufficiently_aged?
-
-      return (s || a)
-    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))
-
-      # touch the age file if needed
-      FileUtils.touch(@age_fn) if @age
-    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
-
-      if ::File.exist?(@fn) then
-        @stat = ::File.stat(@fn)
-        return unless @lockfile
-        return if @inode == @stat.ino
-
-        @io.close rescue nil
-      end
-      open_logfile
-    rescue SystemCallError
-      raise if retry_cnt > 3
-      retry_cnt += 1
-      sleep 0.08
-      retry
-    end
-
-  end  # class RollingFile
-end  # module Logging::Appenders
-
-# EOF

data/lib/logging/lib/logging/appenders/string_io.rb

@@ -1,68 +0,0 @@
-
-module Logging::Appenders
-
-  # This class provides an Appender that can write to a StringIO instance.
-  # This is very useful for testing log message output.
-  #
-  class StringIo < ::Logging::Appenders::IO
-
-    # The StringIO instance the appender is writing to.
-    attr_reader :sio
-
-    # call-seq:
-    #    StringIo.new( name, opts = {} )
-    #
-    # Creates a new StrinIo appender that will append log messages to a
-    # StringIO instance.
-    #
-    def initialize( name, opts = {} )
-      @sio = StringIO.new
-      @sio.extend IoToS
-      @pos = 0
-      super(name, @sio, opts)
-    end
-
-    # Clears the internal StringIO instance. All log messages are removed
-    # from the buffer.
-    #
-    def clear
-      sync {
-        @pos = 0
-        @sio.seek 0
-        @sio.truncate 0
-      }
-    end
-    alias :reset :clear
-
-    %w[read readline readlines].each do|m|
-      class_eval <<-CODE
-        def #{m}( *args )
-          sync {
-            begin
-              @sio.seek @pos
-              rv = @sio.#{m}(*args)
-              @pos = @sio.tell
-              rv
-            rescue EOFError
-              nil
-            end
-          }
-        end
-      CODE
-    end
-
-    # :stopdoc:
-    module IoToS
-      def to_s
-        seek 0
-        str = read
-        seek 0
-        return str
-      end
-    end
-    # :startdoc:
-
-  end  # class StringIo
-end  # module Logging::Appenders
-
-# EOF

data/lib/logging/lib/logging/appenders/syslog.rb

@@ -1,194 +0,0 @@
-
-# only load this class if we have the syslog library
-# Windows does not have syslog
-#
-if HAVE_SYSLOG
-
-module Logging::Appenders
-
-  # This class provides an Appender that can write to the UNIX syslog
-  # daemon.
-  #
-  class Syslog < ::Logging::Appender
-    include ::Syslog::Constants
-
-    # call-seq:
-    #    Syslog.new( name, opts = {} )
-    #
-    # Create an appender that will log messages to the system message
-    # logger. The message is then written to the system console, log files,
-    # logged-in users, or forwarded to other machines as appropriate. The
-    # options that can be used to configure the appender are as follows:
-    #
-    #    :ident     => identifier string (name is used by default)
-    #    :logopt    => options used when opening the connection
-    #    :facility  => the syslog facility to use
-    #
-    # The parameter :ident is a string that will be prepended to every
-    # message. The :logopt argument is a bit field specifying logging
-    # options, which is formed by OR'ing one or more of the following
-    # values:
-    #
-    #    LOG_CONS      If syslog() cannot pass the message to syslogd(8) it
-    #                  wil attempt to write the message to the console
-    #                  ('/dev/console').
-    #
-    #    LOG_NDELAY    Open the connection to syslogd(8) immediately. Normally
-    #                  the open is delayed until the first message is logged.
-    #                  Useful for programs that need to manage the order in
-    #                  which file descriptors are allocated.
-    #
-    #    LOG_PERROR    Write the message to standard error output as well to
-    #                  the system log.
-    #
-    #    LOG_PID       Log the process id with each message: useful for
-    #                  identifying instantiations of daemons.
-    #
-    # The :facility parameter encodes a default facility to be assigned to
-    # all messages that do not have an explicit facility encoded:
-    #
-    #    LOG_AUTH      The authorization system: login(1), su(1), getty(8),
-    #                  etc.
-    #
-    #    LOG_AUTHPRIV  The same as LOG_AUTH, but logged to a file readable
-    #                  only by selected individuals.
-    #
-    #    LOG_CONSOLE   Messages written to /dev/console by the kernel console
-    #                  output driver.
-    #
-    #    LOG_CRON      The cron daemon: cron(8).
-    #
-    #    LOG_DAEMON    System daemons, such as routed(8), that are not
-    #                  provided for explicitly by other facilities.
-    #
-    #    LOG_FTP       The file transfer protocol daemons: ftpd(8), tftpd(8).
-    #
-    #    LOG_KERN      Messages generated by the kernel. These cannot be
-    #                  generated by any user processes.
-    #
-    #    LOG_LPR       The line printer spooling system: lpr(1), lpc(8),
-    #                  lpd(8), etc.
-    #
-    #    LOG_MAIL      The mail system.
-    #
-    #    LOG_NEWS      The network news system.
-    #
-    #    LOG_SECURITY  Security subsystems, such as ipfw(4).
-    #
-    #    LOG_SYSLOG    Messages generated internally by syslogd(8).
-    #
-    #    LOG_USER      Messages generated by random user processes. This is
-    #                  the default facility identifier if none is specified.
-    #
-    #    LOG_UUCP      The uucp system.
-    #
-    #    LOG_LOCAL0    Reserved for local use. Similarly for LOG_LOCAL1
-    #                  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)
-
-      # provides a mapping from the default Logging levels
-      # to the syslog levels
-      @map = [LOG_DEBUG, LOG_INFO, LOG_WARNING, LOG_ERR, LOG_CRIT]
-
-      map = opts.getopt(:map)
-      self.map = map unless map.nil?
-
-      super
-    end
-
-    # call-seq:
-    #    map = { logging_levels => syslog_levels }
-    #
-    # Configure the mapping from the Logging levels to the syslog levels.
-    # This is needed in order to log events at the proper syslog level.
-    #
-    # Without any configuration, the following maping will be used:
-    #
-    #    :debug  =>  LOG_DEBUG
-    #    :info   =>  LOG_INFO
-    #    :warn   =>  LOG_WARNING
-    #    :error  =>  LOG_ERR
-    #    :fatal  =>  LOG_CRIT
-    #
-    def map=( levels )
-      map = []
-      levels.keys.each do |lvl|
-        num = ::Logging.level_num(lvl)
-        map[num] = syslog_level_num(levels[lvl])
-      end
-      @map = map
-    end
-
-    # call-seq:
-    #    close
-    #
-    # Closes the connetion to the syslog facility.
-    #
-    def close( footer = true )
-      super
-      @syslog.close
-      self
-    end
-
-    # call-seq:
-    #    closed?    => true or false
-    #
-    # Queries the connection to the syslog facility and returns +true+ if
-    # the connection is closed.
-    #
-    def closed?
-      !@syslog.opened?
-    end
-
-
-    private
-
-    # call-seq:
-    #    write( 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 write( event )
-      pri = LOG_DEBUG
-      message = if event.instance_of?(::Logging::LogEvent)
-          pri = @map[event.level]
-          @layout.format(event)
-        else
-          event.to_s
-        end
-      return if message.empty?
-
-      @syslog.log(pri, '%s', message)
-      self
-    end
-
-    # call-seq:
-    #    syslog_level_num( level )    => integer
-    #
-    # Takes the given _level_ as a string, symbol, or integer and returns
-    # the corresponding syslog level number.
-    #
-    def syslog_level_num( level )
-      case level
-      when Integer; level
-      when String, Symbol
-        level = level.to_s.upcase
-        self.class.const_get level
-      else
-        raise ArgumentError, "unkonwn level '#{level}'"
-      end
-    end
-
-  end  # class Syslog
-
-end  # module Logging::Appenders
-end  # HAVE_SYSLOG
-
-# EOF