revolutionhealth-log4r 2.0.0

data/lib/log4r/outputter/outputter.rb

@@ -0,0 +1,132 @@
+# :include: ../rdoc/outputter
+#
+# == Other Info
+#
+# Version:: $Id: outputter.rb,v 1.6 2003/09/12 23:55:43 fando Exp $
+# Author:: Leon Torres <leon@ugcs.caltech.edu>
+
+require "thread"
+
+require "log4r/outputter/outputterfactory"
+require "log4r/formatter/formatter"
+require "log4r/staticlogger"
+
+module Log4r
+
+  class Outputter
+    attr_reader :name, :level, :formatter
+    @@outputters = Hash.new
+
+    # An Outputter needs a name. RootLogger will be loaded if not already
+    # done. The hash arguments are as follows:
+    # 
+    # [<tt>:level</tt>]       Logger level. Optional, defaults to root level
+    # [<tt>:formatter</tt>]   A Formatter. Defaults to DefaultFormatter
+
+    def initialize(_name, hash={})
+      if _name.nil?
+        raise ArgumentError, "Bad arguments. Name and IO expected.", caller
+      end
+      @name = _name
+      validate_hash(hash)
+      @@outputters[@name] = self
+    end
+
+    # dynamically change the level
+    def level=(_level)
+      Log4rTools.validate_level(_level)
+      @level = _level
+      OutputterFactory.create_methods(self)
+      Logger.log_internal {"Outputter '#{@name}' level is #{LNAMES[_level]}"}
+    end
+
+    # Set the levels to log. All others will be ignored
+    def only_at(*levels)
+      raise ArgumentError, "Gimme some levels!", caller if levels.empty?
+      raise ArgumentError, "Can't log only_at ALL", caller if levels.include? ALL
+      levels.each {|level| Log4rTools.validate_level(level)}
+      @level = levels.sort.first
+      OutputterFactory.create_methods self, levels
+      Logger.log_internal {
+        "Outputter '#{@name}' writes only on " +\
+        levels.collect{|l| LNAMES[l]}.join(", ")
+      }
+    end
+
+    # Dynamically change the formatter. You can just specify a Class
+    # object and the formatter will invoke +new+ or +instance+
+    # on it as appropriate.
+ 
+    def formatter=(_formatter)
+      if _formatter.kind_of?(Formatter)
+        @formatter = _formatter
+      elsif _formatter.kind_of?(Class) and _formatter <= Formatter
+        if _formatter.respond_to? :instance
+          @formatter = _formatter.instance
+        else
+          @formatter = _formatter.new
+        end
+      else
+        raise TypeError, "Argument was not a Formatter!", caller
+      end
+      Logger.log_internal {"Outputter '#{@name}' using #{@formatter.class}"}
+    end
+
+    # Call flush to force an outputter to write out any buffered
+    # log events. Similar to IO#flush, so use in a similar fashion.
+
+    def flush
+    end
+
+    #########
+    protected
+    #########
+
+    # Validates the common hash arguments. For now, that would be
+    # +:level+, +:formatter+ and the string equivalents
+    def validate_hash(hash)
+      @mutex = Mutex.new
+      # default to root level and DefaultFormatter
+      if hash.empty?
+        self.level = Logger.root.level
+        @formatter = DefaultFormatter.new
+        return
+      end
+      self.level = (hash[:level] or hash['level'] or Logger.root.level)
+      self.formatter = (hash[:formatter] or hash['formatter'] or DefaultFormatter.new)
+    end
+
+    #######
+    private
+    #######
+
+    # This method handles all log events passed to a typical Outputter. 
+    # Overload this to change the overall behavior of an outputter. Make
+    # sure that the new behavior is thread safe.
+
+    def canonical_log(logevent)
+      synch { write(format(logevent)) }
+    end
+
+    # Common method to format data. All it does is call the resident
+    # formatter's format method. If a different formatting behavior is 
+    # needed, then overload this method.
+
+    def format(logevent)
+      # @formatter is guaranteed to be DefaultFormatter if no Formatter
+      # was specified
+      @formatter.format(logevent)
+    end
+
+    # Abstract method to actually write the data to a destination.
+    # Custom outputters should overload this to specify how the
+    # formatted data should be written and to where. 
+   
+    def write(data)
+    end
+
+    def synch; @mutex.synchronize { yield } end
+    
+  end
+
+end

data/lib/log4r/outputter/outputterfactory.rb

@@ -0,0 +1,59 @@
+# :nodoc:
+# Version: $Id: outputterfactory.rb,v 1.3 2002/01/28 16:05:05 cepheus Exp $
+
+require "log4r/base"
+require "log4r/repository"
+require "log4r/logger"
+
+module Log4r
+class Outputter
+
+  class OutputterFactory #:nodoc:
+    include Singleton
+    
+      # handles two cases: logging above a level (no second arg specified)
+      # or logging a set of levels (passed into the second argument)
+      def self.create_methods(out, levels=nil)
+        Logger.root # force levels to be loaded
+
+        # first, undefine all the log levels
+        for mname in LNAMES
+          undefine_log(mname.downcase, out)
+        end
+        if not levels.nil? and levels.include? OFF
+          raise TypeError, "Can't log only_at OFF", caller[1..-1]
+        end
+        return out if out.level == OFF
+
+        if levels.nil? # then define the log methods for lev >= outlev
+          for lev in out.level...LEVELS
+            define_log(LNAMES[lev].downcase, lev, out)
+          end
+        else # define the logs only for assigned levels
+          for lev in levels
+            define_log(LNAMES[lev].downcase, lev, out)
+          end
+        end
+        return out
+      end
+
+      # we need to synch the actual write/format for thread safteyness
+      def self.define_log(mname, level, out)
+        return if mname == 'off' || mname == 'all'
+        mstr = %-
+          def out.#{mname}(logevent)
+            canonical_log(logevent)
+          end
+        -
+        module_eval mstr
+      end
+      
+      def self.undefine_log(mname, out)
+        return if mname == 'off' || mname == 'all'
+        mstr = "def out.#{mname}(logevent); end"
+        module_eval mstr
+      end
+  end
+
+end
+end

data/lib/log4r/outputter/remoteoutputter.rb

@@ -0,0 +1,40 @@
+# :nodoc:
+require 'log4r/lib/drbloader'
+require 'log4r/outputter/outputter'
+
+module Log4r
+  # See log4r/logserver.rb
+  class RemoteOutputter < Outputter
+
+    def initialize(_name, hash={})
+      super(_name, hash)
+      @uri = (hash[:uri] or hash['uri'])
+      @buffsize = (hash[:buffsize] or hash['buffsize'] or 1).to_i
+      @buff = []
+      connect
+    end
+    
+    if HAVE_ROMP
+      include ROMPClient
+    else
+      def initialize(*args)
+        raise RuntimeError, "LogServer not supported. ROMP is required", caller
+      end
+    end
+
+
+    # Call flush to send any remaining LogEvents to the remote server.
+    def flush
+      synch { send_buffer }
+    end
+
+    private
+
+    def canonical_log(logevent)
+      synch {
+        @buff.push logevent
+        send_buffer if @buff.size >= @buffsize
+      }
+    end
+  end
+end

data/lib/log4r/outputter/rollingfileoutputter.rb

@@ -0,0 +1,171 @@
+
+# :nodoc:
+# Version:: $Id: rollingfileoutputter.rb,v 1.4 2003/09/12 23:55:43 fando Exp $
+
+require "log4r/outputter/fileoutputter"
+require "log4r/staticlogger"
+
+module Log4r
+
+  # RollingFileOutputter - subclass of FileOutputter that rolls files on size
+  # or time. Additional hash arguments are:
+  #
+  # [<tt>:maxsize</tt>]   Maximum size of the file in bytes.
+  # [<tt>:trunc</tt>]	  Maximum age of the file in seconds.
+  class RollingFileOutputter < FileOutputter
+
+    attr_reader :count, :maxsize, :maxtime, :startTime, :maxBackupIndex #,i:baseFilename
+
+    def initialize(_name, hash={})
+      @count = 0
+      @max_backup_index = 10
+      super(_name, hash)
+      set_maxsize(hash)
+      if hash.has_key?(:maxtime) || hash.has_key?('maxtime') 
+        _maxtime = (hash[:maxtime] or hash['maxtime']).to_i
+        if _maxtime.class != Fixnum
+          raise TypeError, "Argument 'maxtime' must be an Fixnum", caller
+        end
+        if _maxtime == 0
+          raise TypeError, "Argument 'maxtime' must be > 0", caller
+        end
+        @maxtime = _maxtime
+        @startTime = Time.now
+      end
+      if hash.has_key?(:maxBackupIndex) || hash.has_key?('maxBackupIndex')
+        _max_backup_index = (hash[:maxBackupIndex] or hash['maxBackupIndex']).to_i
+        if _max_backup_index.class != Fixnum
+          raise TypeError, "Argument 'maxsize' must be an Fixnum", caller
+        end
+        if _max_backup_index == 0
+          raise TypeError, "Argument 'maxsize' must be > 0", caller
+        end
+        @max_backup_index = _max_backup_index
+      end
+      @baseFilename = File.basename(@filename)
+      # roll immediately so all files are of the form "000001-@baseFilename"
+      roll if file_size_requires_roll?
+      # initialize the file size counter
+      @datasize = 0
+    end
+
+    #######
+    private
+    #######
+    
+    def set_maxsize(options) 
+      if options.has_key?(:maxsize) || options.has_key?('maxsize')
+        maxsize = (options[:maxsize] or options['maxsize'])
+
+        multiplier = 1
+        if (maxsize =~ /\d+KB/)
+          multiplier = 1024
+        elsif (maxsize =~ /\d+MB/)
+          multiplier = 1024 * 1024
+        elsif (maxsize =~ /\d+GB/)
+          multiplier = 1024 * 1024 * 1024
+        end
+        
+        _maxsize = maxsize.to_i * multiplier
+        
+        if _maxsize.class != Fixnum and _maxsize.class != Bignum
+          raise TypeError, "Argument 'maxsize' must be an Fixnum", caller
+        end
+        if _maxsize == 0
+          raise TypeError, "Argument 'maxsize' must be > 0", caller
+        end
+        @maxsize = _maxsize
+      end
+    end
+
+    # perform the write
+    def write(data) 
+      # we have to keep track of the file size ourselves - File.size doesn't
+      # seem to report the correct size when the size changes rapidly
+      @datasize += data.size + 1 # the 1 is for newline
+      super
+      roll if requiresRoll
+    end
+
+    # construct a new filename from the count and baseFilname
+    def makeNewFilename
+      # note use of hard coded 6 digit counter width - is this enough files?
+      pad = "0" * (6 - @count.to_s.length) + count.to_s
+      newbase = @baseFilename.sub(/(\.\w*)$/, pad + '\1')
+      @filename = File.join(File.dirname(@filename), newbase)
+      Logger.log_internal {"File #{@filename} created"}
+    end 
+
+    # does the file require a roll?
+    def requiresRoll
+      if !@maxsize.nil? && @datasize > @maxsize
+        @datasize = 0
+        return true
+      end
+      if !@maxtime.nil? && (Time.now - @startTime) > @maxtime
+        @startTime = Time.now
+        return true
+      end
+      false
+    end 
+    
+    def indexed_filename(index)
+      @filename + ".#{index}"
+    end
+
+    # more expensive, only for startup
+    def file_size_requires_roll?
+      (@maxsize.to_i > 0 and (File.size?(@filename).to_i >= @maxsize.to_i))
+    end
+    
+    # roll the file
+    def roll
+      begin
+        @out.close
+      rescue 
+        Logger.log_internal {
+          "RollingFileOutputter '#{@name}' could not close #{@filename}"
+        }
+      end
+      @count += 1
+
+      @max_backup_index.times do |x| 
+        index = @max_backup_index - x - 1
+        if File.exists?(indexed_filename(index)) and index != 0
+          FileUtils.mv(indexed_filename(index), indexed_filename(index + 1))
+        elsif index == 0 and File.exists?(@filename)
+          FileUtils.mv(@filename, indexed_filename(index + 1))
+        end
+      end
+
+      @out = File.new(@filename, (@trunc ? "w" : "a"))
+    end 
+
+  end
+
+end
+
+# this can be found in examples/fileroll.rb as well
+if __FILE__ == $0
+  require 'log4r'
+  include Log4r
+
+
+  timeLog = Logger.new 'WbExplorer'
+  timeLog.outputters = RollingFileOutputter.new("WbExplorer", { "filename" => "TestTime.log", "maxtime" => 10, "trunc" => true })
+  timeLog.level = DEBUG
+
+  100.times { |t|
+    timeLog.info "blah #{t}"
+    sleep(1.0)
+  }
+
+  sizeLog = Logger.new 'WbExplorer'
+  sizeLog.outputters = RollingFileOutputter.new("WbExplorer", { "filename" => "TestSize.log", "maxsize" => 16000, "trunc" => true })
+  sizeLog.level = DEBUG
+
+  10000.times { |t|
+    sizeLog.info "blah #{t}"
+  }
+
+end

data/lib/log4r/outputter/staticoutputter.rb

@@ -0,0 +1,30 @@
+# :nodoc:
+module Log4r
+
+  class Outputter
+    # Retrieve an outputter.
+    def self.[](name)
+    out = @@outputters[name]
+      if out.nil?
+        return case name
+        when 'stdout' then StdoutOutputter.new 'stdout'
+        when 'stderr' then StderrOutputter.new 'stderr'
+        else nil end
+      end          
+      out
+    end
+    def self.stdout; Outputter['stdout'] end
+    def self.stderr; Outputter['stderr'] end
+    # Set an outputter.
+    def self.[]=(name, outputter)
+      @@outputters[name] = outputter
+    end
+    # Yields each outputter's name and reference.
+    def self.each
+      @@outputters.each {|name, outputter| yield name, outputter}
+    end
+    def self.each_outputter
+      @@outputters.each_value {|outputter| yield outputter}
+    end
+  end
+end

data/lib/log4r/outputter/syslogoutputter.rb

@@ -0,0 +1,122 @@
+# :include: ../rdoc/syslogoutputter
+#
+# Version:: $Id: syslogoutputter.rb,v 1.5 2004/03/17 20:18:00 fando Exp $
+# Author:: Steve Lumos
+# Author:: Leon Torres
+
+begin
+require 'syslog'
+
+module Log4r
+
+  class SyslogOutputter < Outputter
+    include Syslog::Constants
+
+    # This is the mapping of syslog levels to integers
+    #(7 = debug, 6 = info, 5 = notice, 4 = warning, 3 = err, 2 = crit, 1 = alert, 0 = emerg, x = nothing)
+    
+    SYSLOG_LOGGER_MAP = {
+      0 => LOG_DEBUG,
+      1 => LOG_DEBUG,
+      2 => LOG_INFO,
+      3 => LOG_WARNING,
+      4 => LOG_ERR,
+      5 => LOG_CRIT,
+      6 => LOG_CRIT
+    } 
+
+    # There are 3 hash arguments
+    #
+    # [<tt>:ident</tt>]     syslog ident, defaults to _name
+    # [<tt>:logopt</tt>]    syslog logopt, defaults to LOG_PID | LOG_CONS
+    # [<tt>:facility</tt>]  syslog facility, defaults to LOG_USER
+    def initialize(_name, hash={})
+      super(_name, hash)
+      ident = (hash[:ident] or _name)
+      logopt = (hash[:logopt] or LOG_PID | LOG_CONS).to_i
+      facility = Syslog::Constants.const_get(hash[:facility]) if hash[:facility] != nil and  Syslog::Constants.const_defined?(hash[:facility])
+      facility ||= Syslog::LOG_LOCAL0
+      @syslog = Syslog.open(ident, logopt, facility)
+    end
+
+    def closed?
+      return !@syslog.opened?
+    end
+    
+    def close
+      @syslog.close unless @syslog.nil?
+      @level = OFF
+      OutputterFactory.create_methods(self)
+      Logger.log_internal {"Outputter '#{@name}' closed Syslog and set to OFF"}
+    end
+
+    private
+
+    def canonical_log(logevent)
+      pri = SYSLOG_LOGGER_MAP[logevent.level]
+      o = logevent.data
+      msg = format(logevent)
+      @syslog.log(pri, '%s', msg)
+    end
+  end
+end
+
+rescue Exception => detail
+  module Log4r
+    class SyslogOutputter < Outputter
+      def initialize(_name, hash={})
+        super(_name, hash)    
+      end
+      
+      ##########
+      # constants from syslog.c, just bogus values for windows
+      LOG_PID = 0
+      LOG_CONS = 1
+      LOG_ODELAY = 2
+      LOG_NDELAY = 3
+      LOG_NOWAIT = 4
+      LOG_PERROR = 5
+      LOG_AUTH = 6
+      LOG_AUTHPRIV = 7
+      LOG_CONSOLE = 8
+      LOG_CRON = 9
+      LOG_DAEMON = 10
+      LOG_FTP = 11
+      LOG_KERN = 12
+      LOG_LPR = 13
+      LOG_MAIL = 14
+      LOG_NEWS = 15
+      LOG_NTP = 16
+      LOG_SECURITY = 17
+      LOG_SYSLOG = 18
+      LOG_USER = 19
+      LOG_UUCP = 20
+      LOG_LOCAL0 = 21
+      LOG_LOCAL1 = 22
+      LOG_LOCAL2 = 23
+      LOG_LOCAL3 = 24
+      LOG_LOCAL4 = 25
+      LOG_LOCAL5 = 26
+      LOG_LOCAL6 = 27
+      LOG_LOCAL7 = 28
+      LOG_EMERG = 29
+      LOG_ALERT = 30
+      LOG_CRIT = 31
+      LOG_ERR = 32
+      LOG_WARNING = 33
+      LOG_NOTICE = 34
+      LOG_INFO = 35
+      LOG_DEBUG = 36
+      
+      
+      def closed?
+        @level == OFF
+      end
+    
+      def close
+        @level = OFF
+        OutputterFactory.create_methods(self)
+      end
+    end
+  end
+end