logging 1.4.3 → 1.5.0

data/History.txt

@@ -1,3 +1,11 @@
+== 1.5.0 / 2011-03-22
+
+Minor Enhancements
+- removed mutexes in favor of IO#syswrite
+- no round tripping through the buffer array when auto_flushing is true
+- added a Proxy object that will log all methods called on it
+- colorization of log messages
+
 == 1.4.3 / 2010-05-31
 
 Bug Fixes

data/Rakefile

@@ -14,12 +14,10 @@ Bones {
   authors      'Tim Pease'
   email        'tim.pease@gmail.com'
   url          'http://rubygems.org/gems/logging'
-  readme_file  'README.rdoc'
-  ignore_file  '.gitignore'
 
   rdoc.exclude << '^data'
   rdoc.include << '^examples/.*\.rb'
-  #rdoc.dir = 'doc/rdoc'
+  rcov.opts    << '-x' << '~/.rvm/'
 
   use_gmail
 
@@ -27,6 +25,6 @@ Bones {
 
   depend_on 'flexmock',     :development => true
   depend_on 'bones-git',    :development => true
-  depend_on 'bones-extras', :development => true
+  depend_on 'bones-rcov',   :development => true
 }
 

data/examples/colorization.rb

@@ -0,0 +1,62 @@
+# :stopdoc:
+#
+# The Pattern layout can colorize log events based on a provided color scheme.
+# The configuration is a two part process. First the color scheme is defined
+# with the level colors and any pattern token colors. This color scheme is
+# then passed by name to the Pattern layout when it is created.
+#
+# The color scheme defines colors to be applied to the level token found in
+# the pattern layout. So that the "info" level will have one color, and the
+# "fatal" level will have a separate color. This applies only to the level
+# token in the Pattern layout.
+#
+# Common tokens can have their own color, too. The date token can be colored
+# blue, and the message token can be colored magenta.
+#
+# Colorization should only be applied to TTY logging destinations like STDOUT
+# and STDERR. Inserting color codes into a log file is generally considered
+# bad from; these color codes cause issues for some command lien programs like
+# "less" and "more".
+#
+# A 'default" color scheme is provided with the Logging framework. In the
+# example below we create our own color scheme called 'bright' and apply it to
+# the 'stdout' appender.
+#
+
+  require 'logging'
+
+  # here we setup a color scheme called 'bright'
+  Logging.color_scheme( 'bright',
+    :levels => {
+      :info  => :green,
+      :warn  => :yellow,
+      :error => :red,
+      :fatal => [:white, :on_red]
+    },
+    :date => :blue,
+    :logger => :cyan,
+    :message => :magenta
+  )
+
+  Logging.appenders.stdout(
+    'stdout',
+    :layout => Logging.layouts.pattern(
+      :pattern => '[%d] %-5l %c: %m\n',
+      :color_scheme => 'bright'
+    )
+  )
+
+  log = Logging.logger['Happy::Colors']
+  log.add_appenders 'stdout'
+  log.level = :debug
+
+  # these log messages will be nicely colored
+  # the level will be colored differently for each message
+  #
+  log.debug "a very nice little debug message"
+  log.info "things are operating nominally"
+  log.warn "this is your last warning"
+  log.error StandardError.new("something went horribly wrong")
+  log.fatal "I Die!"
+
+# :startdoc:

data/lib/logging.rb

@@ -3,12 +3,10 @@
 # Used to prevent the class/module from being loaded more than once
 unless defined? Logging
 
-require File.expand_path(
-    File.join(File.dirname(__FILE__), %w[logging utils]))
+require File.expand_path('../logging/utils', __FILE__)
 
 require 'yaml'
 require 'stringio'
-require 'thread'
 require 'fileutils'
 require 'little-plugger'
 
@@ -20,8 +18,8 @@ module Logging
   extend LittlePlugger
 
   # :stopdoc:
-  LIBPATH = ::File.expand_path(::File.dirname(__FILE__)) + ::File::SEPARATOR
-  PATH = ::File.dirname(LIBPATH) + ::File::SEPARATOR
+  LIBPATH = ::File.expand_path('..', __FILE__) + ::File::SEPARATOR
+  PATH = ::File.expand_path('../..', __FILE__) + ::File::SEPARATOR
   LEVELS = {}
   LNAMES = []
   module Plugins; end
@@ -161,6 +159,21 @@ module Logging
       ::Logging::Appenders
     end
 
+    # Returns the color scheme identified by the given _name_. If there is no
+    # color scheme +nil+ is returned.
+    #
+    # If color scheme options are supplied then a new color scheme is created.
+    # Any existing color scheme with the given _name_ will be replaced by the
+    # new color scheme.
+    #
+    def color_scheme( name, opts = {} )
+      if opts.empty?
+        ::Logging::ColorScheme[name]
+      else
+        ::Logging::ColorScheme.new(name, opts)
+      end
+    end
+
     # Reopen all appenders. This method should be called immediately after a
     # fork to ensure no conflict with file descriptors and calls to fcntl or
     # flock.
@@ -290,7 +303,6 @@ module Logging
       module_eval "MAX_LEVEL_LENGTH = #{longest.length}", __FILE__, __LINE__
 
       initialize_plugins
-
       levels.keys
     end
 
@@ -468,7 +480,7 @@ module Logging
 
     # Convert the given level into a level number.
     def level_num( level )
-      l = levelify level
+      l = levelify(level) rescue level
       case l
       when 'all'; 0
       when 'off'; LEVELS.length
@@ -490,6 +502,7 @@ module Logging
     def reset
       ::Logging::Repository.reset
       ::Logging::Appenders.reset
+      ::Logging::ColorScheme.reset
       LEVELS.clear
       LNAMES.clear
       remove_instance_variable :@backtrace if defined? @backtrace
@@ -509,8 +522,10 @@ Logging.libpath {
   require 'logging/repository'
   require 'logging/root_logger'
   require 'logging/stats'
+  require 'logging/color_scheme'
   require 'logging/appenders'
   require 'logging/layouts'
+  require 'logging/proxy'
 
   require 'logging/config/configurator'
   require 'logging/config/yaml_configurator'
@@ -525,4 +540,3 @@ at_exit {Logging.shutdown}
 
 end  # unless defined?
 
-# EOF

data/lib/logging/appender.rb

@@ -45,8 +45,8 @@ class Appender
     header = @layout.header
 
     unless header.nil? || header.empty?
-      begin 
-        sync {write(header)}
+      begin
+        write(header)
       rescue StandardError => err
         ::Logging.log_internal(-2) {err}
       end
@@ -71,7 +71,7 @@ class Appender
     # appender level
     unless @level > event.level
       begin
-        sync {write(event)}
+        write(event)
       rescue StandardError => err
         ::Logging.log_internal(-2) {err}
       end
@@ -94,7 +94,7 @@ class Appender
 
     unless @level >= ::Logging::LEVELS.length
       begin
-        sync {write(str)}
+        write(str)
       rescue StandardError => err
         ::Logging.log_internal(-2) {err}
       end
@@ -170,13 +170,13 @@ class Appender
     ::Logging::Appenders.remove(@name)
     @closed = true
 
-    sync {flush}
+    flush
 
     if footer
       footer = @layout.footer
       unless footer.nil? || footer.empty?
         begin
-          sync {write(footer)}
+          write(footer)
         rescue StandardError => err
           ::Logging.log_internal(-2) {err}
         end
@@ -229,7 +229,7 @@ class Appender
   end
 
 
-  private 
+private
 
   # call-seq:
   #    write( event )

data/lib/logging/appenders/buffering.rb

@@ -26,12 +26,20 @@ module Logging::Appenders
     #
     attr_reader :auto_flushing
 
-    # This message must be implemented by the including class. The method
-    # should write the contents of the buffer to the logging destination,
-    # and it should clear the buffer when done.
+    # 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
-      raise NotImplementedError
+      return self if @buffer.empty?
+
+      str = nil
+      sync {
+        str = @buffer.join
+        @buffer.clear
+      }
+
+      canonical_write str unless str.empty?
+      self
     end
 
     # Configure the levels that will trigger and immediate flush of the
@@ -61,7 +69,7 @@ module Logging::Appenders
         when String; level.split(',').map {|x| x.strip}
         when Array; level
         else Array(level) end
-      
+
       immediate_at.each do |lvl|
         num = ::Logging.level_num(lvl)
         next if num.nil?
@@ -108,7 +116,7 @@ module Logging::Appenders
     end
 
 
-    protected
+  protected
 
     # Configure the buffering using the arguments found in the give options
     # hash. This method must be called in order to use the message buffer.
@@ -124,20 +132,6 @@ module Logging::Appenders
       self.auto_flushing = opts.getopt(:auto_flushing, true)
     end
 
-    # Append the given event to the message buffer. The event can be either
-    # a string or a LogEvent object.
-    #
-    def add_to_buffer( event )
-      str = event.instance_of?(::Logging::LogEvent) ?
-            layout.format(event) : event.to_s
-      return if str.empty?
-
-      buffer << str
-      flush if buffer.length >= auto_flushing || immediate?(event)
-
-      self
-    end
-
     # Returns true if the _event_ level matches one of the configured
     # immediate logging levels. Otherwise returns false.
     #
@@ -147,7 +141,7 @@ module Logging::Appenders
     end
 
 
-    private
+  private
 
     # call-seq:
     #    write( event )
@@ -156,13 +150,25 @@ module Logging::Appenders
     # 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.
     #
+    # The _event_ will be formatted and then buffered until the
+    # "auto_flushing" level has been reached. At thsi time the canonical_write
+    # method will be used to log all events stored in the buffer.
+    #
     def write( event )
-      add_to_buffer event
+      str = event.instance_of?(::Logging::LogEvent) ?
+            layout.format(event) : event.to_s
+      return if str.empty?
+
+      if @auto_flushing == 1
+        canonical_write(str)
+      else
+        sync { @buffer << str }
+        flush if @buffer.length >= @auto_flushing || immediate?(event)
+      end
+
       self
     end
 
-
   end  # module Buffering
 end  # module Logging::Appenders
 
-# EOF

data/lib/logging/appenders/email.rb

@@ -42,21 +42,20 @@ class Email < ::Logging::Appender
     @params   = [@server, @port, @domain, @acct, @passwd, @authtype]
   end
 
-  # call-seq:
-  #    flush
-  #
-  # Create and send an email containing the current message buffer.
-  #
-  def flush
-    return self if buffer.empty?
 
+private
+
+  # This method is called by the buffering code when messages need to be
+  # sent out as an email.
+  #
+  def canonical_write( str )
     ### 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 << buffer.join
+    rfc822msg << str
 
     ### send email
     Net::SMTP.start(*@params) {|smtp| smtp.sendmail(rfc822msg, @from, @to)}
@@ -65,11 +64,8 @@ class Email < ::Logging::Appender
     self.level = :off
     ::Logging.log_internal {'e-mail notifications have been disabled'}
     ::Logging.log_internal(-2) {err}
-  ensure
-    buffer.clear
   end
 
 end   # class Email
 end   # module Logging::Appenders
 
-# EOF

data/lib/logging/appenders/file.rb

@@ -64,7 +64,6 @@ module Logging::Appenders
         end
         @closed = false
         @io = ::File.new(@fn, @mode)
-        @io.sync = true
       }
       self
     end

data/lib/logging/appenders/io.rb

@@ -15,13 +15,11 @@ module Logging::Appenders
     # stream as the logging destination.
     #
     def initialize( name, io, opts = {} )
-      unless io.respond_to? :write
+      unless io.respond_to? :syswrite
         raise TypeError, "expecting an IO object but got '#{io.class.name}'"
       end
 
       @io = io
-      @io.sync = true if @io.respond_to?(:sync) rescue nil
-
       configure_buffering(opts)
       super(name, opts)
     end
@@ -44,26 +42,22 @@ module Logging::Appenders
       return self
     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.
+
+  private
+
+    # This method is called by the buffering code when messages need to be
+    # written to the logging destination.
     #
-    def flush
+    def canonical_write( str )
       return self if @io.nil?
-      @io.write(buffer.join) unless buffer.empty?
-      @io.flush
+      @io.syswrite str
       self
     rescue StandardError => err
       self.level = :off
       ::Logging.log_internal {"appender #{name.inspect} has been disabled"}
       ::Logging.log_internal(-2) {err}
-    ensure
-      buffer.clear
     end
 
   end  # class IO
 end  # module Logging::Appenders
 
-# EOF

data/lib/logging/appenders/rolling_file.rb

@@ -168,29 +168,21 @@ module Logging::Appenders
         end
         @closed = false
         @io = ::File.new(@fn, 'a')
-        @io.sync = true
       }
       self
     end
 
 
-    private
+  private
 
-    alias :_write :write
-
-    # call-seq:
-    #    write( event )
-    #
     # Write the given _event_ to the log file. The log file will be rolled
     # if the maximum file size is exceeded or if the file is older than the
     # maximum age.
     #
-    def write( event )
-      str = event.instance_of?(::Logging::LogEvent) ?
-            @layout.format(event) : event.to_s
-      return if str.empty?
+    def canonical_write( str )
+      return self if @io.nil?
 
-      @io.flock_sh { _write(str) }
+      @io.flock_sh { @io.syswrite(str) }
 
       if roll_required?
         @io.flock? {
@@ -199,6 +191,11 @@ module Logging::Appenders
         }
         @roller.roll_files
       end
+      self
+    rescue StandardError => err
+      self.level = :off
+      ::Logging.log_internal {"appender #{name.inspect} has been disabled"}
+      ::Logging.log_internal(-2) {err}
     end
 
     # Returns +true+ if the log file needs to be rolled.
@@ -326,4 +323,3 @@ module Logging::Appenders
   end  # class RollingFile
 end  # module Logging::Appenders
 
-# EOF