filterfish-logging 0.9.8

data/lib/logging/appender.rb

@@ -0,0 +1,257 @@
+# $Id$
+
+require 'thread'
+
+module Logging
+
+# The +Appender+ class is provides methods for appending log events to a
+# logging destination. The log events are formatted into strings using a
+# Layout.
+#
+# All other Appenders inherit from this class which provides stub methods.
+# Each subclass should provide a +write+ method that will write log
+# messages to the logging destination.
+#
+# A private +sync+ method is provided for use by subclasses. It is used to
+# synchronize writes to the logging destination, and can be used by
+# subclasses to synchronize the closing or flushing of the logging
+# destination.
+#
+class Appender
+
+  @appenders = Hash.new
+
+  class << self
+
+    # call-seq:
+    #    Appender[name]
+    #
+    # Returns the appender instance stroed in the Appender hash under the
+    # key _name_, or +nil+ if no appender has been created using that name.
+    #
+    def []( name ) @appenders[name] end
+
+    # call-seq:
+    #    Appender[name] = appender
+    #
+    # Stores the given _appender_ instance in the Appender hash under the
+    # key _name_.
+    #
+    def []=( name, val ) @appenders[name] = val end
+
+    # call-seq:
+    #    Appenders.remove( name )
+    #
+    # Removes the appender instance stored in the Appender hash under the
+    # key _name_.
+    #
+    def remove( name ) @appenders.delete(name) end
+
+    # call-seq:
+    #    Appender.stdout
+    #
+    # Returns an instance of the Stdout Appender. Unless the user explicitly
+    # creates a new Stdout Appender, the instance returned by this method
+    # will always be the same:
+    #
+    #    Appender.stdout.object_id == Appender.stdout.object_id    #=> true
+    #
+    def stdout( ) self['stdout'] || ::Logging::Appenders::Stdout.new end
+
+    # call-seq:
+    #    Appender.stderr
+    #
+    # Returns an instance of the Stderr Appender. Unless the user explicitly
+    # creates a new Stderr Appender, the instance returned by this method
+    # will always be the same:
+    #
+    #    Appender.stderr.object_id == Appender.stderr.object_id    #=> true
+    #
+    def stderr( ) self['stderr'] || ::Logging::Appenders::Stderr.new end
+
+  end  # class << self
+
+  attr_reader :name, :layout, :level
+
+  # call-seq:
+  #    Appender.new( name )
+  #    Appender.new( name, :layout => layout )
+  #
+  # Creates a new appender using the given name. If no Layout is specified,
+  # then a Basic layout will be used. Any logging header supplied by the
+  # layout will be written to the logging destination when the Appender is
+  # created.
+  #
+  def initialize( name, opts = {} )
+    @name = name.to_s
+    @closed = false
+
+    self.layout = opts.getopt(:layout, ::Logging::Layouts::Basic.new)
+    self.level = opts.getopt(:level)
+
+    @mutex = Mutex.new
+    header = @layout.header
+    sync {write(header)} unless header.nil? || header.empty?
+
+    ::Logging::Appender[@name] = self
+  end
+
+  # call-seq:
+  #    append( event )
+  #
+  # Write the given _event_ to the logging destination. The log event will
+  # be processed through the Layout associated with the Appender.
+  #
+  def append( event )
+    if @closed
+      raise RuntimeError,
+            "appender '<#{self.class.name}: #{@name}>' is closed"
+    end
+
+    sync {write(event)} unless @level > event.level
+    self
+  end
+
+  # call-seq:
+  #    appender << string
+  #
+  # Write the given _string_ to the logging destination "as is" -- no
+  # layout formatting will be performed.
+  #
+  def <<( str )
+    if @closed
+      raise RuntimeError,
+            "appender '<#{self.class.name}: #{@name}>' is closed"
+    end
+
+    sync {write(str)} unless @level >= ::Logging::LEVELS.length
+    self
+  end
+
+  # call-seq:
+  #    level = :all
+  #
+  # Set the level for this appender; log events below this level will be
+  # ignored by this appender. The level can be either a +String+, a
+  # +Symbol+, or a +Fixnum+. An +ArgumentError+ is raised if this is not
+  # the case.
+  #
+  # There are two special levels -- "all" and "off". The former will
+  # enable recording of all log events. The latter will disable the
+  # recording of all events.
+  #
+  # Example:
+  #
+  #    appender.level = :debug
+  #    appender.level = "INFO"
+  #    appender.level = 4
+  #    appender.level = 'off'
+  #    appender.level = :all
+  #
+  # These prodcue an +ArgumentError+
+  #
+  #    appender.level = Object
+  #    appender.level = -1
+  #    appender.level = 1_000_000_000_000
+  #
+  def level=( level )
+    lvl = case level
+          when String, Symbol; ::Logging::level_num(level)
+          when Fixnum; level
+          when nil; 0
+          else
+            raise ArgumentError,
+                  "level must be a String, Symbol, or Integer"
+          end
+    if lvl.nil? or lvl < 0 or lvl > ::Logging::LEVELS.length
+      raise ArgumentError, "unknown level was given '#{level}'"
+    end
+
+    @level = lvl
+  end
+
+  # call-seq
+  #    appender.layout = Logging::Layouts::Basic.new
+  #
+  # Sets the layout to be used by this appender.
+  #
+  def layout=( layout )
+    unless layout.kind_of? ::Logging::Layout
+      raise TypeError,
+            "#{layout.inspect} is not a kind of 'Logging::Layout'"
+    end
+    @layout = layout
+  end
+
+  # call-seq:
+  #    close( footer = true )
+  #
+  # Close the appender and writes the layout footer to the logging
+  # destination if the _footer_ flag is set to +true+. Log events will
+  # no longer be written to the logging destination after the appender
+  # is closed.
+  #
+  def close( footer = true )
+    return self if @closed
+    ::Logging::Appender.remove(@name)
+    @closed = true
+    if footer
+      footer = @layout.footer
+      sync {write(footer)} unless footer.nil? || footer.empty?
+    end
+    self
+  end
+
+  # call-seq:
+  #    closed?
+  #
+  # Returns +true+ if the appender has been closed; returns +false+
+  # otherwise. When an appender is closed, no more log events can be
+  # written to the logging destination.
+  #
+  def closed?
+    @closed
+  end
+
+  # call-seq:
+  #    flush
+  #
+  # Call +flush+ to force an appender to write out any buffered log events.
+  # Similar to IO#flush, so use in a similar fashion.
+  #
+  def flush
+    self
+  end
+
+
+  private 
+
+  # call-seq:
+  #    write( event )
+  #
+  # Writes the given _event_ to the logging destination. Subclasses should
+  # provide an implementation of this method. The _event_ can be either a
+  # LogEvent or a String. If a LogEvent, then it will be formatted using
+  # the layout given to the appender when it was created.
+  #
+  def write( event )
+    nil
+  end
+
+  # call-seq:
+  #    sync { block }
+  #
+  # Obtains an exclusive lock, runs the block, and releases the lock when
+  # the block completes. This method is re-entrant so that a single thread
+  # can call +sync+ multiple times without hanging the thread.
+  #
+  def sync
+    @mutex.synchronize {yield}
+  end
+
+end  # class Appender
+end  # module Logging
+
+Logging.require_all_libs_relative_to(__FILE__, 'appenders')
+
+# EOF

data/lib/logging/appenders/console.rb

@@ -0,0 +1,43 @@
+# $Id$
+
+require Logging.libpath(*%w[logging appenders io])
+
+module Logging::Appenders
+
+  # This class provides an Appender that can write to STDOUT.
+  #
+  class Stdout < ::Logging::Appenders::IO
+
+    # call-seq:
+    #    Stdout.new
+    #    Stdout.new( :layout => layout )
+    #
+    # Creates a new Stdout Appender. The name 'stdout' will always be used
+    # for this appender.
+    #
+    def initialize( name = nil, opts = {} )
+      name ||= 'stdout'
+      super(name, STDOUT, opts)
+    end
+  end  # class Stdout
+
+  # This class provides an Appender that can write to STDERR.
+  #
+  class Stderr < ::Logging::Appenders::IO
+
+    # call-seq:
+    #    Stderr.new
+    #    Stderr.new( :layout => layout )
+    #
+    # Creates a new Stderr Appender. The name 'stderr' will always be used
+    # for this appender.
+    #
+    def initialize( name = nil, opts = {} )
+      name ||= 'stderr'
+      super(name, STDERR, opts)
+    end
+  end  # class Stderr
+
+end  # module Logging::Appenders
+
+# EOF

data/lib/logging/appenders/email.rb

@@ -0,0 +1,131 @@
+# $Id$
+
+require 'net/smtp'
+require 'time' # get rfc822 time format
+
+# a replacement EmailOutputter.  This is essentially the default EmailOutptter from Log4r but with the following
+# changes:
+#   1) if there is data to send in an email, then do not send anything
+#   2) connect to the smtp server at the last minute, do not connect at startup and then send later on.
+#   3) Fix the To: field so that it looks alright.
+module Logging::Appenders
+
+class Email < ::Logging::Appender
+
+  attr_reader :server, :port, :domain, :acct, :authtype, :subject
+
+  def initialize( name, opts = {} )
+    super(name, opts)
+
+    @buff = []
+    @buffsize = opts.getopt :buffsize, 100, :as => Integer
+
+    # get the immediate levels -- no buffering occurs at these levels, and
+    # an e-mail is sent as soon as possible
+    @immediate = []
+    opts.getopt(:immediate_at, '').split(',').each do |lvl|
+      num = ::Logging.level_num(lvl.strip)
+      next if num.nil?
+      @immediate[num] = true
+    end
+
+    # get the SMTP parameters
+    @from = opts.getopt(:from)
+    raise ArgumentError, 'Must specify from address' if @from.nil?
+
+    @to = opts.getopt(:to, '').split(',')
+    raise ArgumentError, 'Must specify recipients' if @to.empty?
+
+    @server   = opts.getopt :server, 'localhost'
+    @port     = opts.getopt :port, 25, :as => Integer
+    @domain   = opts.getopt(:domain, ENV['HOSTNAME']) || 'localhost.localdomain'
+    @acct     = opts.getopt :acct
+    @passwd   = opts.getopt :passwd
+    @authtype = opts.getopt :authtype, :cram_md5, :as => Symbol
+    @subject  = opts.getopt :subject, "Message of #{$0}"
+    @params   = [@server, @port, @domain, @acct, @passwd, @authtype]
+  end
+  
+  # call-seq:
+  #    flush
+  #
+  # Create and send an email containing the current message buffer.
+  #
+  def flush
+    sync { send_mail }
+    self
+  end
+
+  # call-seq:
+  #    close( footer = true )
+  #
+  # Close the e-mail appender and then flush the message buffer. This will
+  # ensure that a final e-mail is sent with any remaining messages.
+  #
+  def close( footer = true )
+    super
+    flush
+  end
+
+  # cal-seq:
+  #    queued_messages    => integer
+  #
+  # Returns the number of messages in the buffer.
+  #
+  def queued_messages
+    @buff.length
+  end
+
+
+  private
+
+  # call-seq:
+  #    write( event )
+  #
+  # Write the given _event_ to the e-mail message buffer. The log event will
+  # be processed through the Layout associated with this appender.
+  #
+  def write( event )
+    immediate = false
+    str = if event.instance_of?(::Logging::LogEvent)
+        immediate = @immediate[event.level]
+        @layout.format(event)
+      else
+        event.to_s
+      end
+    return if str.empty?
+
+    @buff << str
+    send_mail if @buff.length >= @buffsize || immediate
+    self
+  end
+
+  # Connect to the mail server and send out any buffered messages.
+  #
+  def send_mail
+    return if @buff.empty?
+
+    ### build a mail header for RFC 822
+    rfc822msg =  "From: #{@from}\n"
+    rfc822msg << "To: #{@to.join(",")}\n"
+    rfc822msg << "Subject: #{@subject}\n"
+    rfc822msg << "Date: #{Time.new.rfc822}\n"
+    rfc822msg << "Message-Id: <#{"%.8f" % Time.now.to_f}@#{@domain}>\n\n"
+    rfc822msg << @buff.join
+
+    ### send email
+    begin 
+      Net::SMTP.start(*@params) {|smtp| smtp.sendmail(rfc822msg, @from, @to)}
+    rescue Exception => e
+      self.level = :off
+      STDERR.puts e.message
+      # TODO - log that e-mail notification has been turned off
+    ensure
+      @buff.clear
+    end
+  end
+
+end   # class Email
+end   # module Logging::Appenders
+
+# EOF

data/lib/logging/appenders/file.rb

@@ -0,0 +1,55 @@
+# $Id$
+
+module Logging::Appenders
+
+  # This class provides an Appender that can write to a File.
+  #
+  class File < ::Logging::Appenders::IO
+
+    # call-seq:
+    #    File.assert_valid_logfile( filename )    => true
+    #
+    # Asserts that the given _filename_ can be used as a log file by ensuring
+    # that if the file exists it is a regular file and it is writable. If
+    # the file does not exist, then the directory is checked to see if it is
+    # writable.
+    #
+    # An +ArgumentError+ is raised if any of these assertions fail.
+    #
+    def self.assert_valid_logfile( fn )
+      if ::File.exist?(fn)
+        if not ::File.file?(fn)
+          raise ArgumentError, "#{fn} is not a regular file"
+        elsif not ::File.writable?(fn)
+          raise ArgumentError, "#{fn} is not writeable"
+        end
+      elsif not ::File.writable?(::File.dirname(fn))
+        raise ArgumentError, "#{::File.dirname(fn)} is not writable"
+      end
+      true
+    end
+
+    # call-seq:
+    #    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
+    # 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.
+    #
+    def initialize( name, opts = {} )
+      @fn = opts.getopt(:filename, name)
+      raise ArgumentError, 'no filename was given' if @fn.nil?
+      self.class.assert_valid_logfile(@fn)
+      mode = opts.getopt(:truncate) ? 'w' : 'a'
+
+      super(name, ::File.new(@fn, mode), opts)
+    end
+
+  end  # class FileAppender
+end  # module Logging::Appenders
+
+# EOF