logsly 1.2.0 → 1.3.0

data/lib/logsly/logging182/appenders/string_io.rb

@@ -0,0 +1,92 @@
+
+module Logsly::Logging182::Appenders
+
+  # Accessor / Factory for the StringIo appender.
+  #
+  def self.string_io( *args )
+    return ::Logsly::Logging182::Appenders::StringIo if args.empty?
+    ::Logsly::Logging182::Appenders::StringIo.new(*args)
+  end
+
+  # This class provides an Appender that can write to a StringIO instance.
+  # This is very useful for testing log message output.
+  #
+  class StringIo < ::Logsly::Logging182::Appenders::IO
+
+    # The StringIO instance the appender is writing to.
+    attr_reader :sio
+
+    # call-seq:
+    #    StringIo.new( name, opts = {} )
+    #
+    # Creates a new StringIo 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
+
+    # Reopen the underlying StringIO instance. If the instance is currently
+    # closed then it will be opened. If the instance is currently open then it
+    # will be closed and immediately opened.
+    #
+    def reopen
+      @mutex.synchronize {
+        if defined? @io and @io
+          flush
+          @io.close rescue nil
+        end
+        @io = @sio = StringIO.new
+        @sio.extend IoToS
+        @pos = 0
+      }
+      super
+      self
+    end
+
+    # Clears the internal StringIO instance. All log messages are removed
+    # from the buffer.
+    #
+    def clear
+      @mutex.synchronize {
+        @pos = 0
+        @sio.seek 0
+        @sio.truncate 0
+      }
+    end
+    alias :reset :clear
+
+    %w[read readline readlines].each do|m|
+      class_eval <<-CODE, __FILE__, __LINE__+1
+        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  # StringIo
+end  # Logsly::Logging182::Appenders
+

data/lib/logsly/logging182/appenders/syslog.rb

@@ -0,0 +1,215 @@
+
+# only load this class if we have the syslog library
+# Windows does not have syslog
+#
+if HAVE_SYSLOG
+
+module Logsly::Logging182::Appenders
+
+  # Accessor / Factory for the Syslog appender.
+  #
+  def self.syslog( *args )
+    return ::Logsly::Logging182::Appenders::Syslog if args.empty?
+    ::Logsly::Logging182::Appenders::Syslog.new(*args)
+  end
+
+  # This class provides an Appender that can write to the UNIX syslog
+  # daemon.
+  #
+  class Syslog < ::Logsly::Logging182::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.  Not available on Solaris.
+    #
+    #    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 Logsly::Logging182 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 Logsly::Logging182 levels to the syslog levels.
+    # This is needed in order to log events at the proper syslog level.
+    #
+    # Without any configuration, the following mapping 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 = ::Logsly::Logging182.level_num(lvl)
+        map[num] = syslog_level_num(levels[lvl])
+      end
+      @map = map
+    end
+
+    # call-seq:
+    #    close
+    #
+    # Closes the connection to the syslog facility.
+    #
+    def close( footer = true )
+      super
+      @syslog.close if @syslog.opened?
+      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
+
+    # Reopen the connection to the underlying logging destination. If the
+    # connection is currently closed then it will be opened. If the connection
+    # is currently open then it will be closed and immediately opened.
+    #
+    def reopen
+      @mutex.synchronize {
+        if @syslog.opened?
+          flush
+          @syslog.close
+        end
+        @syslog = ::Syslog.open(@ident, @logopt, @facility)
+      }
+      super
+      self
+    end
+
+
+    private
+
+    # call-seq:
+    #    write( event )
+    #
+    # Write the given _event_ to the syslog facility. The log event will be
+    # processed through the Layout associated 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?(::Logsly::Logging182::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  # Syslog
+end  # Logsly::Logging182::Appenders
+end  # HAVE_SYSLOG
+

data/lib/logsly/logging182/appenders.rb

@@ -0,0 +1,64 @@
+
+module Logsly::Logging182
+  module Appenders
+
+    # call-seq:
+    #    Appenders[name]
+    #
+    # Returns the appender instance stored 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:
+    #    Appenders[name] = appender
+    #
+    # Stores the given _appender_ instance in the appender hash under the
+    # key _name_.
+    #
+    def []=( name, value ) @appenders[name] = value 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:
+    #    each {|appender| block}
+    #
+    # Yield each appender to the _block_.
+    #
+    def each( &block )
+      @appenders.values.each(&block)
+      return nil
+    end
+
+    # :stopdoc:
+    def reset
+      @appenders.values.each {|appender|
+        next if appender.nil?
+        appender.close
+      }
+      @appenders.clear
+      return nil
+    end
+    # :startdoc:
+
+    extend self
+    @appenders = Hash.new
+  end  # Appenders
+
+  require 'logsly/logging182/appenders/buffering'
+  require 'logsly/logging182/appenders/io'
+  require 'logsly/logging182/appenders/console'
+  require 'logsly/logging182/appenders/email'
+  require 'logsly/logging182/appenders/file'
+  require 'logsly/logging182/appenders/growl'
+  require 'logsly/logging182/appenders/rolling_file'
+  require 'logsly/logging182/appenders/string_io'
+  require 'logsly/logging182/appenders/syslog'
+end  # Logsly::Logging182
+

data/lib/logsly/logging182/color_scheme.rb

@@ -0,0 +1,248 @@
+
+# color_scheme.rb
+#
+# Created by Jeremy Hinegardner on 2007-01-24
+# Copyright 2007.  All rights reserved
+#
+# This is Free Software.  See LICENSE and COPYING for details
+
+module Logsly::Logging182
+
+  # ColorScheme objects encapsulate a named set of colors to be used in the
+  # colors() method call. For example, by applying a ColorScheme that
+  # has a <tt>:warning</tt> color then the following could be used:
+  #
+  #   scheme.color("This is a warning", :warning)
+  #
+  # ColorScheme objects are used by the Pattern layout code to colorize log
+  # messages. Each color scheme is given a unique name which is used by the
+  # Pattern layout to lookup the appropriate color scheme to use. Please
+  # refer to the Pattern layout documentation for more details - specifically
+  # the initializer documentation.
+  #
+  # The color scheme can be applied to the Pattern layout in several ways.
+  # Each token in the log pattern can be colorized with the log level (debug,
+  # info, warn, etc) receiving unique colors based on the level itself.
+  # Another option is to colorize the entire log message based on the log
+  # level; in this mode tokens do not get their own colors. Please see the
+  # ColorScheme initializer for the list of colorization options.
+  #
+  class ColorScheme
+
+    class << self
+      # Retrieve a color scheme by name.
+      #
+      def []( name )
+        @color_schemes[name.to_s]
+      end
+
+      # Store a color scheme by name.
+      #
+      def []=( name, value )
+        raise ArgumentError, "Silly! That's not a ColorSchmeme!" unless ColorScheme === value
+        @color_schemes[name.to_s] = value
+      end
+
+      # Clear all color schemes and setup a default color scheme.
+      #
+      def reset
+        @color_schemes ||= {}
+        @color_schemes.clear
+
+        new(:default, :levels => {
+          :info  => :green,
+          :warn  => :yellow,
+          :error => :red,
+          :fatal => [:white, :on_red]
+        })
+      end
+    end
+
+    # Create a ColorScheme instance that can be accessed using the given
+    # _name_. If a color scheme already exists with the given _name_ it will
+    # be replaced by the new color scheme.
+    #
+    # The color names are passed as options to the method with each name
+    # mapping to one or more color codes. For example:
+    #
+    #    ColorScheme.new('example', :logger => [:white, :on_green], :message => :magenta)
+    #
+    # The color codes are the lowercase names of the constants defined at the
+    # end of this file. Multiple color codes can be aliased by grouping them
+    # in an array as shown in the example above.
+    #
+    # Since color schemes are primary intended to be used with the Pattern
+    # layout, there are a few special options of note. First the log levels
+    # are enumerated in their own hash:
+    #
+    #    :levels => {
+    #      :debug => :blue,
+    #      :info  => :cyan,
+    #      :warn  => :yellow,
+    #      :error => :red,
+    #      :fatal => [:white, :on_red]
+    #    }
+    #
+    # The log level token will be colorized differently based on the value of
+    # the log level itself. Similarly the entire log message can be colorized
+    # based on the value of the log level. A different option should be given
+    # for this behavior:
+    #
+    #    :lines => {
+    #      :debug => :blue,
+    #      :info  => :cyan,
+    #      :warn  => :yellow,
+    #      :error => :red,
+    #      :fatal => [:white, :on_red]
+    #    }
+    #
+    # The :levels and :lines options cannot be used together; only one or the
+    # other should be given.
+    #
+    # The remaining tokens defined in the Pattern layout can be colorized
+    # using the following aliases. Their meaning in the Pattern layout are
+    # repeated here for sake of clarity.
+    #
+    #    :logger       [%c] name of the logger that generate the log event
+    #    :date         [%d] datestamp
+    #    :message      [%m] the user supplied log message
+    #    :pid          [%p] PID of the current process
+    #    :time         [%r] the time in milliseconds since the program started
+    #    :thread       [%T] the name of the thread Thread.current[:name]
+    #    :thread_id    [%t] object_id of the thread
+    #    :file         [%F] filename where the logging request was issued
+    #    :line         [%L] line number where the logging request was issued
+    #    :method       [%M] method name where the logging request was issued
+    #
+    # Please refer to the "examples/colorization.rb" file for a working
+    # example of log colorization.
+    #
+    def initialize( name, opts = {} )
+      @scheme = Hash.new
+
+      @lines = opts.key? :lines
+      @levels = opts.key? :levels
+      raise ArgumentError, "Found both :lines and :levels - only one can be used." if lines? and levels?
+
+      lines = opts.delete :lines
+      levels = opts.delete :levels
+
+      load_from_hash(opts)
+      load_from_hash(lines) if lines?
+      load_from_hash(levels) if levels?
+
+      ::Logsly::Logging182::ColorScheme[name] = self
+    end
+
+    # Load multiple colors from key/value pairs.
+    #
+    def load_from_hash( h )
+      h.each_pair do |color_tag, constants|
+        self[color_tag] = constants
+      end
+    end
+
+    # Returns +true+ if the :lines option was passed to the constructor.
+    #
+    def lines?
+      @lines
+    end
+
+    # Returns +true+ if the :levels option was passed to the constructor.
+    #
+    def levels?
+      @levels
+    end
+
+    # Does this color scheme include the given tag name?
+    #
+    def include?( color_tag )
+      @scheme.key?(to_key(color_tag))
+    end
+
+    # Allow the scheme to be accessed like a Hash.
+    #
+    def []( color_tag )
+      @scheme[to_key(color_tag)]
+    end
+
+    # Allow the scheme to be set like a Hash.
+    #
+    def []=( color_tag, constants )
+      @scheme[to_key(color_tag)] = constants.respond_to?(:map) ?
+          constants.map { |c| to_constant(c) }.join : to_constant(constants)
+    end
+
+    # This method provides easy access to ANSI color sequences, without the user
+    # needing to remember to CLEAR at the end of each sequence.  Just pass the
+    # _string_ to color, followed by a list of _colors_ you would like it to be
+    # affected by.  The _colors_ can be ColorScheme class constants, or symbols
+    # (:blue for BLUE, for example).  A CLEAR will automatically be embedded to
+    # the end of the returned String.
+    #
+    def color( string, *colors )
+      colors.map! { |color|
+        color_tag = to_key(color)
+        @scheme.key?(color_tag) ? @scheme[color_tag] : to_constant(color)
+      }
+
+      colors.compact!
+      return string if colors.empty?
+
+      "#{colors.join}#{string}#{CLEAR}"
+    end
+
+  private
+
+    # Return a normalized representation of a color name.
+    #
+    def to_key( t )
+      t.to_s.downcase
+    end
+
+    # Return a normalized representation of a color setting.
+    #
+    def to_constant( v )
+      v = v.to_s.upcase
+      ColorScheme.const_get(v) if (ColorScheme.const_defined?(v, false) rescue ColorScheme.const_defined?(v))
+    end
+
+    # Embed in a String to clear all previous ANSI sequences.  This *MUST* be
+    # done before the program exits!
+    CLEAR      = "\e[0m".freeze
+    RESET      = CLEAR              # An alias for CLEAR.
+    ERASE_LINE = "\e[K".freeze      # Erase the current line of terminal output.
+    ERASE_CHAR = "\e[P".freeze      # Erase the character under the cursor.
+    BOLD       = "\e[1m".freeze     # The start of an ANSI bold sequence.
+    DARK       = "\e[2m".freeze     # The start of an ANSI dark sequence.  (Terminal support uncommon.)
+    UNDERLINE  = "\e[4m".freeze     # The start of an ANSI underline sequence.
+    UNDERSCORE = UNDERLINE          # An alias for UNDERLINE.
+    BLINK      = "\e[5m".freeze     # The start of an ANSI blink sequence.  (Terminal support uncommon.)
+    REVERSE    = "\e[7m".freeze     # The start of an ANSI reverse sequence.
+    CONCEALED  = "\e[8m".freeze     # The start of an ANSI concealed sequence.  (Terminal support uncommon.)
+
+    BLACK      = "\e[30m".freeze    # Set the terminal's foreground ANSI color to black.
+    RED        = "\e[31m".freeze    # Set the terminal's foreground ANSI color to red.
+    GREEN      = "\e[32m".freeze    # Set the terminal's foreground ANSI color to green.
+    YELLOW     = "\e[33m".freeze    # Set the terminal's foreground ANSI color to yellow.
+    BLUE       = "\e[34m".freeze    # Set the terminal's foreground ANSI color to blue.
+    MAGENTA    = "\e[35m".freeze    # Set the terminal's foreground ANSI color to magenta.
+    CYAN       = "\e[36m".freeze    # Set the terminal's foreground ANSI color to cyan.
+    WHITE      = "\e[37m".freeze    # Set the terminal's foreground ANSI color to white.
+
+    ON_BLACK   = "\e[40m".freeze    # Set the terminal's background ANSI color to black.
+    ON_RED     = "\e[41m".freeze    # Set the terminal's background ANSI color to red.
+    ON_GREEN   = "\e[42m".freeze    # Set the terminal's background ANSI color to green.
+    ON_YELLOW  = "\e[43m".freeze    # Set the terminal's background ANSI color to yellow.
+    ON_BLUE    = "\e[44m".freeze    # Set the terminal's background ANSI color to blue.
+    ON_MAGENTA = "\e[45m".freeze    # Set the terminal's background ANSI color to magenta.
+    ON_CYAN    = "\e[46m".freeze    # Set the terminal's background ANSI color to cyan.
+    ON_WHITE   = "\e[47m".freeze    # Set the terminal's background ANSI color to white.
+
+  end  # ColorScheme
+
+  # setup the default color scheme
+  ColorScheme.reset
+
+end  # Logsly::Logging182
+