logging 1.4.3 → 1.5.0

data/lib/logging/appenders/string_io.rb

@@ -65,4 +65,3 @@ module Logging::Appenders
   end  # class StringIo
 end  # module Logging::Appenders
 
-# EOF

data/lib/logging/appenders/syslog.rb

@@ -131,7 +131,7 @@ module Logging::Appenders
     #
     def close( footer = true )
       super
-      @syslog.close
+      @syslog.close if @syslog.opened?
       self
     end
 

data/lib/logging/color_scheme.rb

@@ -0,0 +1,249 @@
+
+# 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 Logging
+
+  # 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
+  # refere 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 enitre 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 schems are primary inteneded 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 dfferent 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?
+
+      ::Logging::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 )
+      ColorScheme.const_get(v.to_s.upcase)
+    rescue NameError
+      return  nil
+    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  # Logging
+

data/lib/logging/layouts/basic.rb

@@ -26,7 +26,6 @@ module Logging::Layouts
               ::Logging::LNAMES[event.level], event.logger, obj)
     end
 
-  end  # class Basic
-end  # module Logging::Layouts
+  end  # Basic
+end  # Logging::Layouts
 
-# EOF

data/lib/logging/layouts/parseable.rb

@@ -65,7 +65,7 @@ module Logging::Layouts
   # own line in the log output. Therefore, to parse the output you must read
   # it line by line and parse the individual objects. Taking the same
   # example above the JSON output would be:
-  # 
+  #
   #   {"timestamp":"2009-04-17 16:15:42","level":"INFO","logger":"Foo::Bar","message":"this is a log message"}
   #   {"timestamp":"2009-04-17 16:15:43","level":"ERROR","logger":"Foo","message":"<RuntimeError> Oooops!!"}
   #
@@ -124,7 +124,7 @@ module Logging::Layouts
         "\\\"#{name}\\\":%s"
       }.join(',')
       code << "}\\n\" % [#{args.join(', ')}]\nend"
-      
+
       (class << layout; self end).class_eval(code, __FILE__, __LINE__)
     end
     # :startdoc:
@@ -183,8 +183,7 @@ module Logging::Layouts
       create_format_method
     end
 
-
-    private
+  private
 
     # Take the given _value_ and format it into a JSON compatible string.
     #
@@ -205,7 +204,6 @@ module Logging::Layouts
       else raise ArgumentError, "unknown format style '#@style'" end
     end
 
-  end  # class Parseable
-end  # module Logging::Layouts
+  end  # Parseable
+end  # Logging::Layouts
 
-# EOF

data/lib/logging/layouts/pattern.rb

@@ -35,7 +35,7 @@ module Logging::Layouts
   # conversion specifier when it reads a conversion character. In the example
   # above the conversion specifier %-5l means the level of the logging event
   # should be left justified to a width of five characters. The recognized
-  # conversion characters are 
+  # conversion characters are
   #
   #  [c]  Used to output the name of the logger that generated the log
   #       event. Supports an optional "precision" described further below.
@@ -95,7 +95,7 @@ module Logging::Layouts
   #
   # Below are various format modifier examples for the category conversion
   # specifier.
-  # 
+  #
   #  [%20c]      Left pad with spaces if the logger name is less than 20
   #              characters long
   #  [%-20c]     Right pad with spaces if the logger name is less than 20
@@ -149,6 +149,20 @@ module Logging::Layouts
     # default date format
     ISO8601 = "%Y-%m-%d %H:%M:%S".freeze
 
+    # Human name aliases for directives - used for colorization of tokens
+    COLOR_ALIAS_TABLE = {
+      'c' => :logger,
+      'd' => :date,
+      'm' => :message,
+      'p' => :pid,
+      'r' => :time,
+      'T' => :thread,
+      't' => :thread_id,
+      'F' => :file,
+      'L' => :line,
+      'M' => :method
+    }.freeze
+
     # call-seq:
     #    Pattern.create_date_format_methods( pf )
     #
@@ -186,19 +200,23 @@ module Logging::Layouts
     #
     def self.create_format_method( pf )
       # Create the format(event) method
-      code = "undef :format if method_defined? :format\n"
-      code << "def format( event )\nsprintf(\""
+      format_string = '"'
       pattern = pf.pattern.dup
+      color_scheme = pf.color_scheme
       args = []
+      name_map_count = 0
 
       while true
         m = DIRECTIVE_RGXP.match(pattern)
-        code << m[1] unless m[1].empty?
+        format_string << m[1] unless m[1].empty?
 
         case m[3]
-        when '%'; code << '%%'
-        when 'c' 
-          code << m[2] + 's'
+        when '%'; format_string << '%%'
+        when 'c'
+          fmt = m[2] + 's'
+          fmt = color_scheme.color(fmt, COLOR_ALIAS_TABLE[m[3]]) if color_scheme and !color_scheme.lines?
+
+          format_string << fmt
           args << DIRECTIVE_TABLE[m[3]].dup
           if m[4]
             raise ArgumentError, "logger name precision must be an integer greater than zero: #{m[4]}" unless Integer(m[4]) > 0
@@ -206,9 +224,28 @@ module Logging::Layouts
                 ".split(::Logging::Repository::PATH_DELIMITER)" \
                 ".last(#{m[4]}).join(::Logging::Repository::PATH_DELIMITER)"
           end
+        when 'l'
+          if color_scheme and color_scheme.levels?
+            name_map = ::Logging::LNAMES.map { |name| color_scheme.color(("#{m[2]}s" % name), name) }
+            var = "@name_map_#{name_map_count}"
+            pf.instance_variable_set(var.to_sym, name_map)
+            name_map_count += 1
+
+            format_string << '%s'
+            format_string << "{#{m[4]}}" if m[4]
+            args << "#{var}[event.level]"
+          else
+            format_string << m[2] + 's'
+            format_string << "{#{m[4]}}" if m[4]
+            args << DIRECTIVE_TABLE[m[3]]
+          end
+
         when *DIRECTIVE_TABLE.keys
-          code << m[2] + 's'
-          code << "{#{m[4]}}" if m[4]
+          fmt = m[2] + 's'
+          fmt = color_scheme.color(fmt, COLOR_ALIAS_TABLE[m[3]]) if color_scheme and !color_scheme.lines?
+
+          format_string << fmt
+          format_string << "{#{m[4]}}" if m[4]
           args << DIRECTIVE_TABLE[m[3]]
         when nil; break
         else
@@ -219,10 +256,19 @@ module Logging::Layouts
         pattern = m[5]
       end
 
-      code << '"'
-      code << ', ' + args.join(', ') unless args.empty?
-      code << ")\n"
-      code << "end\n"
+      format_string << '"'
+
+      sprintf = "sprintf("
+      sprintf << format_string
+      sprintf << ', ' + args.join(', ') unless args.empty?
+      sprintf << ")"
+
+      if color_scheme and color_scheme.lines?
+        sprintf = "color_scheme.color(#{sprintf}, ::Logging::LNAMES[event.level])"
+      end
+
+      code = "undef :format if method_defined? :format\n"
+      code << "def format( event )\n#{sprintf}\nend\n"
       ::Logging.log_internal(0) {code}
 
       pf._meta_eval(code, __FILE__, __LINE__)
@@ -237,9 +283,16 @@ module Logging::Layouts
     #    :pattern       =>  "[%d] %-5l -- %c : %m\n"
     #    :date_pattern  =>  "%Y-%m-%d %H:%M:%S"
     #    :date_method   =>  'usec' or 'to_s'
+    #    :color_scheme  =>  :default
     #
     # If used, :date_method will supersede :date_pattern.
     #
+    # The :color_scheme is used to apply color formatting to the log messages.
+    # Individual tokens can be colorized witch the level token [%l] receiving
+    # distinct colors based on the level of the log event. The entire
+    # generated log message can also be colorized based on the level of the
+    # log event. See the ColorScheme documentation for more details.
+    #
     def initialize( opts = {} )
       super
       @created_at = Time.now
@@ -251,11 +304,18 @@ module Logging::Layouts
       @pattern = opts.getopt(:pattern,
           "[%d] %-#{::Logging::MAX_LEVEL_LENGTH}l -- %c : %m\n")
 
+      cs_name = opts.getopt(:color_scheme)
+      @color_scheme =
+          case cs_name
+          when false, nil; nil
+          when true; ::Logging::ColorScheme[:default]
+          else ::Logging::ColorScheme[cs_name] end
+
       Pattern.create_date_format_methods(self)
       Pattern.create_format_method(self)
     end
 
-    attr_reader :pattern, :date_pattern, :date_method
+    attr_reader :pattern, :date_pattern, :date_method, :color_scheme
 
     # call-seq:
     #    appender.pattern = "[%d] %-5l -- %c : %m\n"
@@ -305,7 +365,6 @@ module Logging::Layouts
     end
     # :startdoc:
 
-  end  # class Pattern
-end  # module Logging::Layouts
+  end  # Pattern
+end  # Logging::Layouts
 
-# EOF