log4r 1.0.6

data/src/log4r/outputter/emailoutputter.rb

@@ -0,0 +1,116 @@
+# :include: ../rdoc/emailoutputter
+
+require 'log4r/outputter/outputter'
+require 'log4r/staticlogger'
+require 'net/smtp'
+
+module Log4r
+
+  class EmailOutputter < Outputter
+    attr_reader :server, :port, :domain, :acct, :authtype, :subject
+
+    def initialize(_name, hash={})
+      super(_name, hash)
+      validate(hash)
+      @buff = []
+      begin 
+        Logger.log_internal {
+          "EmailOutputter '#{@name}' running SMTP client on #{@server}:#{@port}"
+        }
+      rescue Exception => e
+        Logger.log_internal(-2) {
+          "EmailOutputter '#{@name}' failed to start SMTP client!"
+        }
+        Logger.log_internal {e}
+        self.level = OFF
+      end
+    end
+
+    # send out an email with the current buffer
+    def flush
+      synch { send_mail }
+      Logger.log_internal {"Flushed EmailOutputter '#{@name}'"}
+    end
+
+    private
+
+    def validate(hash)
+      @buffsize = (hash[:buffsize] or hash['buffsize'] or 100).to_i
+      @formatfirst = Log4rTools.decode_bool(hash, :formatfirst, false)
+      decode_immediate_at(hash)
+      validate_smtp_params(hash)
+    end
+
+    def decode_immediate_at(hash)
+      @immediate = Hash.new
+      _at = (hash[:immediate_at] or hash['immediate_at'])
+      return if _at.nil?
+      Log4rTools.comma_split(_at).each {|lname|
+        level = LNAMES.index(lname)
+        if level.nil?
+          Logger.log_internal(-2) do
+            "EmailOutputter: skipping bad immediate_at level name '#{lname}'"
+          end
+          next
+        end
+        @immediate[level] = true
+      }
+    end
+
+    def validate_smtp_params(hash)
+      @from = (hash[:from] or hash['from'])
+      raise ArgumentError, "Must specify from address" if @from.nil?
+      _to = (hash[:to] or hash['to'] or "")
+      @to = Log4rTools.comma_split(_to) 
+      raise ArgumentError, "Must specify recepients" if @to.empty?
+      @server = (hash[:server] or hash['server'] or 'localhost')
+      @port = (hash[:port] or hash['port'] or 25).to_i
+      @domain = (hash[:domain] or hash['domain'] or ENV['HOSTNAME'])
+      @acct = (hash[:acct] or hash['acct'])
+      @passwd = (hash[:passwd] or hash['passwd'])
+      @authtype = (hash[:authtype] or hash['authtype'] or :cram_md5).to_s.intern
+      @subject = (hash[:subject] or hash['subject'] or "Message of #{$0}")
+      @params = [@server, @port, @domain, @acct, @passwd, @authtype]
+    end
+
+    def canonical_log(event)
+      synch {
+        @buff.push case @formatfirst
+          when true then @formatter.format event
+          else event 
+          end
+        send_mail if @buff.size >= @buffsize or @immediate[event.level]
+      }
+    end
+
+    def send_mail
+      msg = 
+        case @formatfirst
+        when true then @buff.join 
+        else @buff.collect{|e| @formatter.format e}.join 
+        end
+
+      ### build a mail header for RFC 822
+      rfc822msg =
+        "From: #{@from}\n" +
+        "To: #{@to}\n" +
+        "Subject: #{@subject}\n" +
+        "Date: #{Time.now.strftime( "%a, %d %b %Y %H:%M:%S %z %Z")}\n" +
+        "Message-Id: <#{"%.8f" % Time.now.to_f}@#{@domain}>\n\n" +
+        "#{msg}"
+
+      ### send email
+      begin Net::SMTP.start(*@params) do |smtp|
+        smtp.sendmail(rfc822msg, @from, @to)
+      end
+      rescue Exception => e
+        Logger.log_internal(-2) {
+          "EmailOutputter '#{@name}' couldn't send email!"
+        }
+        Logger.log_internal {e}
+        self.level = OFF
+      ensure @buff.clear
+      end
+    end
+  end
+end

data/src/log4r/outputter/fileoutputter.rb

@@ -0,0 +1,49 @@
+# :nodoc:
+# Version:: $Id: fileoutputter.rb,v 1.1.1.1 2004/03/19 03:31:09 fando Exp $
+
+require "log4r/outputter/iooutputter"
+require "log4r/staticlogger"
+
+module Log4r
+
+  # Convenience wrapper for File. Additional hash arguments are:
+  #
+  # [<tt>:filename</tt>]   Name of the file to log to.
+  # [<tt>:trunc</tt>]      Truncate the file?
+  class FileOutputter < IOOutputter
+    attr_reader :trunc, :filename
+
+    def initialize(_name, hash={})
+      super(_name, nil, hash)
+
+      @trunc = Log4rTools.decode_bool(hash, :trunc, true)
+      _filename = (hash[:filename] or hash['filename'])
+
+      if _filename.class != String
+        raise TypeError, "Argument 'filename' must be a String", caller
+      end
+
+      # file validation
+      if FileTest.exist?( _filename )
+        if not FileTest.file?( _filename )
+          raise StandardError, "'#{_filename}' is not a regular file", caller
+        elsif not FileTest.writable?( _filename )
+          raise StandardError, "'#{_filename}' is not writable!", caller
+        end
+      else # ensure directory is writable
+        dir = File.dirname( _filename )
+        if not FileTest.writable?( dir )
+          raise StandardError, "'#{dir}' is not writable!"
+        end
+      end
+
+      @filename = _filename
+      @out = File.new(@filename, (@trunc ? "w" : "a")) 
+      Logger.log_internal {
+        "FileOutputter '#{@name}' writing to #{@filename}"
+      }
+    end
+
+  end
+  
+end

data/src/log4r/outputter/iooutputter.rb

@@ -0,0 +1,55 @@
+# :nodoc:
+require "log4r/outputter/outputter"
+require "log4r/staticlogger"
+
+module Log4r
+  
+  ##
+  # IO Outputter invokes print then flush on the wrapped IO
+  # object. If the IO stream dies, IOOutputter sets itself to OFF
+  # and the system continues on its merry way.
+  #
+  # To find out why an IO stream died, create a logger named 'log4r'
+  # and look at the output.
+
+  class IOOutputter < Outputter
+
+    # IOOutputter needs an IO object to write to.
+    def initialize(_name, _out, hash={})
+      super(_name, hash)
+      @out = _out
+    end
+
+    def closed?
+      @out.closed?
+    end
+
+    # Close the IO and sets level to OFF
+    def close
+      @out.close unless @out.nil?
+      @level = OFF
+      OutputterFactory.create_methods(self)
+      Logger.log_internal {"Outputter '#{@name}' closed IO and set to OFF"}
+    end
+
+    #######
+    private
+    #######
+    
+    # perform the write
+    def write(data)
+      begin
+        @out.print data
+        @out.flush
+      rescue IOError => ioe # recover from this instead of crash
+        Logger.log_internal {"IOError in Outputter '#{@name}'!"}
+        Logger.log_internal {ioe}
+        close
+      rescue NameError => ne
+        Logger.log_internal {"Outputter '#{@name}' IO is #{@out.class}!"}
+        Logger.log_internal {ne}
+        close
+      end
+    end
+  end
+end

data/src/log4r/outputter/outputter.rb

@@ -0,0 +1,132 @@
+# :include: ../rdoc/outputter
+#
+# == Other Info
+#
+# Version:: $Id: outputter.rb,v 1.1.1.1 2004/03/19 03:31:09 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/src/log4r/outputter/outputterfactory.rb

@@ -0,0 +1,59 @@
+# :nodoc:
+# Version: $Id: outputterfactory.rb,v 1.1.1.1 2004/03/19 03:31:09 fando 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/src/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