log4ruby 0.0.3 → 0.0.4

data/lib/log4ruby/appender.rb

@@ -1,57 +1,64 @@
-#
-# 21 Jul 2012
-#
-
-module Log4Ruby
-
-  # Base class for appenders.
-  class Appender
-
-    # Set the formatter this appender uses.
-    attr_writer :formatter
-
-    # New appender. This class should be treated as an abstract base class and should not be initialised directly.
-    #
-    # @param [Log4Ruby::Level] level the threshold level for the appender.
-    # @param [Log4Ruby::Formatter] formatter the formatter the appender uses.
-    def initialize(level, formatter)
-      @level = level
-      @formatter = formatter
-      @closed = false
-    end
-
-    # Closes this appender. Logs will not be emitted by this appender any longer.
-    #
-    # @return [TrueClass] Always true.
-    def close
-      @closed = true
-    end
-
-    # Check if this appender is closed.
-    #
-    # @return [TrueClass, FalseClass] true if the appender is closed.
-    def closed?
-      @closed
-    end
-
-    # Process the log item.
-    #
-    # @param [Log4Ruby::Log] log
-    def process_log(log)
-      return if log[:level] < @level
-
-      # Format the log item and emit it.
-      emit(@formatter.format(log))
-    end
-
-    private
-
-    # Emits a log message to this appenders target.
-    #
-    # @param [String] message the message to emit.
-    def emit(message)
-    end
-
-  end
-
+#
+# 21 Jul 2012
+#
+
+require "log4ruby/formatters/default_formatter"
+
+module Log4Ruby
+
+  # Base class for appenders.
+  class Appender
+
+    # Set the formatter this appender uses.
+    attr_writer :formatter
+
+    # New appender. This class should be treated as an abstract base class and should not be initialised directly.
+    #
+    # @param [Log4Ruby::Level] level the threshold level for the appender.
+    # @param [Hash] options configuration options. Supported keys are:
+    #   :formatter - the formatter this appender should use. Uses the DefaultFormatter if not specified.
+    def initialize(level, options = {})
+      @level = level
+      @formatter = get_option(options, :formatter, false, DefaultFormatter.new)
+      @closed = false
+
+      at_exit { close }
+    end
+
+    # Closes this appender. Logs will not be emitted by this appender any longer.
+    # If the appender is already closed, this method should not do anything.
+    #
+    # @return [TrueClass] Always true.
+    def close
+      @closed = true
+    end
+
+    # Check if this appender is closed.
+    #
+    # @return [TrueClass, FalseClass] true if the appender is closed.
+    def closed?
+      @closed
+    end
+
+    # Process the log item.
+    #
+    # @param [Log4Ruby::Log] log
+    def process_log(log)
+      return if self.closed?
+      return if log[:level] < @level
+
+      # Format the log item and emit it.
+      emit(@formatter.format(log))
+    end
+
+    private
+
+    # Emits a log message to this appenders target.
+    #
+    # @param [String] message the message to emit.
+    def emit(message)
+    end
+
+  end
+
 end

data/lib/log4ruby/appenders/console_appender.rb

@@ -13,10 +13,16 @@ module Log4Ruby
 
     # New console appender.
     #
-    # @param [Symbol] target either stdout or stderr.
-    def initialize(level, formatter, target = :stdout)
+    # @param [Log4Ruby::Level] level the threshold level for the appender.
+    # @param [Hash] options configuration options. Supported keys are:
+    #   :formatter - the formatter this appender should use. Uses the DefaultFormatter if not specified.
+    #   :target - the target stream to use (:stdout or :stderr). Default is :stdout
+    def initialize(level, options = {})
+      target = get_option(options, :target, false, :stdout)
       raise ArgumentError.new("Invalid target '#{target}'. Must be either 'stdout' or 'stderr'.") unless TARGETS.has_key?(target)
-      super(level, formatter, TARGETS[target])
+
+      set_option(options, :stream, TARGETS[target], true)
+      super(level, options)
     end
 
   end

data/lib/log4ruby/appenders/file_appender.rb

@@ -3,6 +3,7 @@
 #
 
 require "date"
+require "fileutils"
 
 require "log4ruby/appenders/stream_appender"
 
@@ -32,6 +33,7 @@ module Log4Ruby
     # New stream appender.
     #
     # @param [Hash] options configuration hash. Supports the following parameters.
+    #  :formatter - the formatter this appender should use. Uses the DefaultFormatter if not specified.
     #  :directory - the directory into which the logs should be saved. Defaults to the current directory.
     #  :prefix - the file name prefix for the log files. *required*
     #  :suffix - the file name suffix for the log files. Defaults to 'log'
@@ -51,8 +53,9 @@ module Log4Ruby
     # roll_using_date:
     #   :frequency - the frequency with which to roll files (:hourly, :daily, :weekly, :monthly, :yearly).
     #   Default is :daily.
-    def initialize(level, formatter, options = {})
-      super(level, formatter, nil)
+    def initialize(level, options = {})
+      set_option(options, :stream, nil, true)
+      super(level, options)
 
       @directory = get_option(options, :directory, false, "./")
       @prefix = get_option(options, :prefix, true)
@@ -106,9 +109,12 @@ module Log4Ruby
       # Create the emit method that will roll using the file date as the trigger.
       class << self
         self
-      end.send(:define_method, :emit) do |message|
-        roll_using_date
-        super(message)
+
+        # Override to roll using the date of the file.
+        def emit(message)
+          roll_using_date
+          super(message)
+        end
       end
     end
 
@@ -122,9 +128,12 @@ module Log4Ruby
       # Create the emit method that will roll using the file size as the trigger.
       class << self
         self
-      end.send(:define_method, :emit) do |message|
-        roll_using_size
-        super(message)
+
+        # Override to roll using the size of the file.
+        def emit(message)
+          roll_using_size
+          super(message)
+        end
       end
     end
 

data/lib/log4ruby/appenders/nil_appender.rb

@@ -1,16 +1,25 @@
-#
-# 21 Jul 2012
-#
-
-module Log4Ruby
-
-  # An appender that does nothing. All logs to it are ignored and just consumed.
-  class NilAppender
-
-    # Don't do anything with the log. Just return.
-    def process_log(log)
-    end
-
-  end
-
+#
+# 21 Jul 2012
+#
+
+require "log4ruby/appender"
+
+module Log4Ruby
+
+  # An appender that does nothing. All logs to it are ignored and just consumed.
+  class NilAppender < Log4Ruby::Appender
+
+    # New NilAppender. Does nothing.
+    #
+    # @param [Log4Ruby::Level] level - not used.
+    # @param [Hash] options - not used.
+    def initialize(level, options = {})
+    end
+
+    # Don't do anything with the log. Just return.
+    def process_log(log)
+    end
+
+  end
+
 end

data/lib/log4ruby/appenders/stream_appender.rb

@@ -1,31 +1,65 @@
-#
-# 21 Jul 2012
-#
-
-require "log4ruby/appender"
-
-module Log4Ruby
-
-  # Simple appender that can emit to a stream (file, console, socket, etc i.e. anything that responds to the write method)
-  class StreamAppender < Log4Ruby::Appender
-
-    # New stream appender.
-    #
-    # @param [IO] stream a IO stream that can respond to the write method.
-    def initialize(level, formatter, stream)
-      super(level, formatter)
-      @stream = stream
-    end
-
-    private
-
-    # Writes the message to the underlying stream.
-    #
-    # @param [String] message the message to write.
-    def emit(message)
-      @stream.write(message)
-    end
-
-  end
-
-end
+#
+# 21 Jul 2012
+#
+
+require "log4ruby/appender"
+
+module Log4Ruby
+
+  # Simple appender that can emit to a stream (file, console, socket, etc i.e. anything that responds to the write method)
+  class StreamAppender < Log4Ruby::Appender
+
+    # New stream appender.
+    #
+    # @param [Log4Ruby::Level] level the threshold level for the appender.
+    # @param [Hash] options configuration options. Supported keys are:
+    #  :formatter - the formatter this appender should use. Uses the DefaultFormatter if not specified.
+    #  :stream - the stream this appender should log to. *required*.
+    def initialize(level, options = {})
+      super(level, options)
+      @stream = get_option(options, :stream)
+      @emit_header = true
+    end
+
+    # Overridden to emit the footer. If closed, does nothing.
+    def close
+      emit_footer unless @closed
+      @stream.close unless (@stream.nil? or @stream.closed?)
+
+      super
+    end
+
+    # Register a block that will serve as the callback for when the footer needs to be generated.
+    def footer(&block)
+      @footer = block
+    end
+
+    # Register a block that will serve as the callback for when the header needs to be generated.
+    def header(&block)
+      @header = block
+    end
+
+    private
+
+    # Emits the footer to the appender's target. This will be executed just before the appender is closed.
+    def emit_footer
+      @footer.call(@stream) unless @footer.nil?
+    end
+
+    # Emits the header to the appender's target. This will be executed just before the first line is emitted.
+    def emit_header
+      @header.call(@stream) unless @header.nil?
+      @emit_header = false
+    end
+
+    # Writes the message to the underlying stream.
+    #
+    # @param [String] message the message to write.
+    def emit(message)
+      emit_header if @emit_header
+      @stream.write(message)
+    end
+
+  end
+
+end

data/lib/log4ruby/formatters/default_formatter.rb

@@ -0,0 +1,23 @@
+#
+# 25 Jul 2012
+#
+
+require "log4ruby/formatter"
+
+module Log4Ruby
+
+  # Default formatter for Log4Ruby.
+  class DefaultFormatter < Log4Ruby::Formatter
+
+    # Format a log item.
+    #
+    # @param [Log4Ruby::Log] log
+    #
+    # @return [String] the fully formatted log message.
+    def format(log)
+      "#{log[:level].name} - #{log[:message]}\n"
+    end
+
+  end
+
+end

data/lib/log4ruby/formatters/pattern_formatter.rb

@@ -1,81 +1,80 @@
-#
-# 21 Jul 2012
-#
-
-require "log4ruby/formatter"
-require "log4ruby/log"
-
-module Log4Ruby
-
-  class PatternFormatter
-
-    # New pattern formatter.
-    #
-    # @param [String] format_string the pattern string to use when formatting log messages.
-    # @param [Array] subst_array the log parameters to substitute into the format string.
-    # @param [Hash] parameter_formatters custom formatters for log parameters. Maps parameter names to callable objects
-    #   that will be invoked with the parameter's value. The values returned will be used when substituting into the
-    #   format string.
-    #
-    # e.g.
-    # format_string = [%s] %7s - %s : %s
-    # subst_array = [:timestamp, :level, :full_logger_name, :message]
-    # custom_formatters = {:timestamp => Proc.new { |value| value.strftime("%Y-%m-%d %H:%M:%S.%L") }}
-    #
-    # The above example will print the timestamp in the format specified.
-    # The level will be right aligned padded on the left to use 7 spaces followed by the full logger name and the
-    # message.
-    def initialize(format_string, subst_array, parameter_formatters = {})
-      @format_string = format_string
-      @subst_array = subst_array
-      @parameter_formatters = parameter_formatters
-    end
-
-    # Adds a parameter formatter to this formatter.
-    #
-    # @param [Symbol] parameter the parameter to format.
-    # @param [Proc] callable the callable to invoke.
-    def add_parameter_formatter(parameter, callable)
-      @parameter_formatters[parameter] = callable
-    end
-
-    # Format the log item using the pattern string.
-    #
-    # @param [Log4Ruby::Log] log the log to format.
-    #
-    # @return [String] the fully formatted log message.
-    def format(log)
-      # Get the values of the parameters (apply custom formatters too).
-      parameters = @subst_array.map do |parameter|
-        value = log[parameter]
-        @parameter_formatters.has_key?(parameter) ? @parameter_formatters[parameter].call(value) : value.to_s
-      end
-      # Substitute into the format string.
-      @format_string % parameters
-    end
-
-  end
-
-  # Some common parameter formatters to use with the pattern formatter.
-  class ParameterFormatters
-
-    # Returns a logger formatter that will format logger objects.
-    #
-    # @param [Integer] index an integer that represents how far up the tree the logger's name should be resolved. So
-    # 1 would be only the name of the logger, 2 would be the name of the logger's parent and the name of the logger,
-    # and so on...
-    def self.logger_formatter(index)
-      start =  0 - index
-      Proc.new { |logger| logger.full_name.split(".")[start..-1].join(".") }
-    end
-
-    # Returns a timestamp formatter that will format time objects using the specified format string.
-    #
-    # @param [String] format_string the format string.
-    def self.timestamp_formatter(format_string)
-      Proc.new { |timestamp| timestamp.strftime(format_string) }
-    end
-
-  end
-
-end
+#
+# 21 Jul 2012
+#
+
+require "log4ruby/formatter"
+require "log4ruby/log"
+
+module Log4Ruby
+
+  class PatternFormatter
+
+    # New pattern formatter.
+    #
+    # @param [String] format_string the pattern string to use when formatting log messages.
+    # @param [Array] subst_array the log parameters to substitute into the format string.
+    # @param [Hash] parameter_formatters custom formatters for log parameters. Maps parameter names to callable objects
+    #   that will be invoked with the parameter's value. The values returned will be used when substituting into the
+    #   format string.
+    #
+    # e.g.
+    # format_string = [%s] %7s - %s : %s
+    # subst_array = [:timestamp, :level, :full_logger_name, :message]
+    #
+    # The above example will print the timestamp in the format specified.
+    # The level will be right aligned padded on the left to use 7 spaces followed by the full logger name and the
+    # message.
+    def initialize(format_string, subst_array, parameter_formatters = {})
+      @format_string = format_string
+      @subst_array = subst_array
+      @parameter_formatters = parameter_formatters
+    end
+
+    # Adds a parameter formatter to this formatter.
+    #
+    # @param [Symbol] parameter the parameter to format.
+    # @param [Proc] callable the callable to invoke.
+    def add_parameter_formatter(parameter, callable)
+      @parameter_formatters[parameter] = callable
+    end
+
+    # Format the log item using the pattern string.
+    #
+    # @param [Log4Ruby::Log] log the log to format.
+    #
+    # @return [String] the fully formatted log message.
+    def format(log)
+      # Get the values of the parameters (apply custom formatters too).
+      parameters = @subst_array.map do |parameter|
+        value = log[parameter]
+        @parameter_formatters.has_key?(parameter) ? @parameter_formatters[parameter].call(value) : value.to_s
+      end
+      # Substitute into the format string.
+      @format_string % parameters
+    end
+
+  end
+
+  # Some common parameter formatters to use with the pattern formatter.
+  class ParameterFormatters
+
+    # Returns a logger formatter that will format logger objects.
+    #
+    # @param [Integer] index an integer that represents how far up the tree the logger's name should be resolved. So
+    # 1 would be only the name of the logger, 2 would be the name of the logger's parent and the name of the logger,
+    # and so on...
+    def self.logger_formatter(index)
+      start =  0 - index
+      Proc.new { |logger| logger.full_name.split(".")[start..-1].join(".") }
+    end
+
+    # Returns a timestamp formatter that will format time objects using the specified format string.
+    #
+    # @param [String] format_string the format string.
+    def self.timestamp_formatter(format_string)
+      Proc.new { |timestamp| timestamp.strftime(format_string) }
+    end
+
+  end
+
+end

data/lib/log4ruby/level.rb

@@ -1,95 +1,95 @@
-#
-# 21 Jul 2012
-#
-
-require "log4ruby/logger"
-
-module Log4Ruby
-
-  class Level
-
-    # Creates a new level with the specified name and weight. Only level's created using this method are
-    # automatically made available on the Logger class. Any other level's will have to be handled manually.
-    # The method with which it is made available is the same as the level, but with all lowercase characters.
-    #
-    # @param [String] name the name of the new level. Will overwrite an existing level with the same name, if it exists.
-    #   The name is converted to all uppercase characters.
-    # @param [Float] weight the weight of the level. Higher the weight, higher the priority.
-    def self.register(name, weight)
-      name = name.upcase
-      method_name = name.downcase
-      query_method_name = "#{method_name}?"
-      level = Level.new(name, weight)
-      const_set(name, level)
-      # Create the logging method.
-      Logger.send(:define_method, method_name) do |message, parameters = {}|
-        return if self.closed?
-        return if level < self.effective_level
-        # Construct the log and dispatch it.
-        parameters[:message] = message
-        parameters[:level] = level
-        parameters[:logger] = self
-        self.process_log(Log.new(parameters))
-      end
-      # Create the query method - for checking the effective level of a logger / appender.
-      Logger.send(:define_method, query_method_name) { self.effective_level <= level  }
-      Appender.send(:define_method, query_method_name) { self.level <= level }
-    end
-
-    # Parses the specified string in an attempt to convert it to a Level object.
-    #
-    # @param [String] name the name of the level.
-    #
-    # @return [Log4Ruby::Level] the level object.
-    def self.parse(name)
-      name = name.upcase
-      const_get(name)
-    end
-
-    # The weight of this level. Higher the value, more severe the log.
-    attr_reader :weight
-    # The name of the level.
-    attr_reader :name
-
-    # Creates a new level.
-    #
-    # @param [String] name the name of the level.
-    # @param [Float] weight the weight for this level. Higher the weight, higher the severity.
-    def initialize(name, weight)
-      @name = name
-      @weight = weight
-    end
-
-    # Check if this level is less than the specified other log level.
-    # Comparison is done using the weight attribute
-    def <(other)
-      self.weight < other.weight
-    end
-
-    # Check if this level is less than or equal to the specified other log level.
-    # Comparison is done using the weight attribute
-    def <=(other)
-      self.weight <= other.weight
-    end
-
-    # Override to return the name of the level.
-    #
-    # @return [String] the level's name.
-    def to_s
-      @name
-    end
-
-    register("ALL", Float::MIN)
-    register("TRACE", 100.0)
-    register("FINE", 200.0)
-    register("DEBUG", 300.0)
-    register("CONF", 400.0)
-    register("INFO", 500.0)
-    register("WARN", 600.0)
-    register("ERROR", 700.0)
-    register("FATAL", 800.0)
-    register("OFF", Float::MAX)
-
-  end
-
+#
+# 21 Jul 2012
+#
+
+require "log4ruby/logger"
+
+module Log4Ruby
+
+  class Level
+
+    # Creates a new level with the specified name and weight. Only level's created using this method are
+    # automatically made available on the Logger class. Any other level's will have to be handled manually.
+    # The method with which it is made available is the same as the level, but with all lowercase characters.
+    #
+    # @param [String] name the name of the new level. Will overwrite an existing level with the same name, if it exists.
+    #   The name is converted to all uppercase characters.
+    # @param [Float] weight the weight of the level. Higher the weight, higher the priority.
+    def self.register(name, weight)
+      name = name.upcase
+      method_name = name.downcase
+      query_method_name = "#{method_name}?"
+      level = Level.new(name, weight)
+      const_set(name, level)
+      # Create the logging method.
+      Logger.send(:define_method, method_name) do |message, parameters = {}|
+        return if self.closed?
+        return if level < self.effective_level
+        # Construct the log and dispatch it.
+        parameters[:message] = message
+        parameters[:level] = level
+        parameters[:logger] = self
+        self.process_log(Log.new(parameters))
+      end
+      # Create the query method - for checking the effective level of a logger / appender.
+      Logger.send(:define_method, query_method_name) { self.effective_level <= level  }
+      Appender.send(:define_method, query_method_name) { self.level <= level }
+    end
+
+    # Parses the specified string in an attempt to convert it to a Level object.
+    #
+    # @param [String] name the name of the level.
+    #
+    # @return [Log4Ruby::Level] the level object.
+    def self.parse(name)
+      name = name.upcase
+      const_get(name)
+    end
+
+    # The weight of this level. Higher the value, more severe the log.
+    attr_reader :weight
+    # The name of the level.
+    attr_reader :name
+
+    # Creates a new level.
+    #
+    # @param [String] name the name of the level.
+    # @param [Float] weight the weight for this level. Higher the weight, higher the severity.
+    def initialize(name, weight)
+      @name = name
+      @weight = weight
+    end
+
+    # Check if this level is less than the specified other log level.
+    # Comparison is done using the weight attribute
+    def <(other)
+      self.weight < other.weight
+    end
+
+    # Check if this level is less than or equal to the specified other log level.
+    # Comparison is done using the weight attribute
+    def <=(other)
+      self.weight <= other.weight
+    end
+
+    # Override to return the name of the level.
+    #
+    # @return [String] the level's name.
+    def to_s
+      @name
+    end
+
+    register("ALL", Float::MIN)
+    register("TRACE", 100.0)
+    register("FINE", 200.0)
+    register("DEBUG", 300.0)
+    register("CONF", 400.0)
+    register("INFO", 500.0)
+    register("WARN", 600.0)
+    register("ERROR", 700.0)
+    register("FATAL", 800.0)
+    register("OFF", Float::MAX)
+
+  end
+
 end

data/lib/log4ruby/logger.rb

@@ -1,148 +1,148 @@
-#
-# 22 Jul 2012
-#
-
-require "singleton"
-
-module Log4Ruby
-
-  # Represents a logger.
-  # Loggers are arranged into a tree, where each logger, after having dispatched the log to its appenders,
-  # forwards the log to its parents too.
-  class Logger
-
-    # The effective level of this logger. This will be the parent's effective level if a level has not been
-    # explicitly set for this logger.
-    attr_reader :effective_level
-    # The full name of this logger.
-    attr_reader :full_name
-    # The name of this logger.
-    attr_reader :name
-    # True to use parent appenders (the default) false to use only this logger's appenders.
-    attr_writer :use_parent_appenders
-
-    # Creates a new logger. Users should not use this method, and should use the Log4Ruby.get_logger method.
-    #
-    # @param [String] name the name for this logger.
-    # @param [Log4Ruby::Logger] parent the parent to this logger. If set to nil, becomes the child of the root logger.
-    # @param [Log4Ruby::Level] level the level of this logger. If set to nil, uses the parent's effective level
-    # (defaults to DEBUG for the root logger).
-    # @param [Array] appenders a list of appenders this logger will use.
-    def initialize(name, parent = nil, level = nil, appenders = [])
-      @name = name
-      @parent = parent.nil? ? RootLogger.instance : parent
-      @level = level
-      @appenders = appenders
-      @children = {}
-      @closed = false
-
-      @use_parent_appenders = true
-      @full_name = @parent.kind_of?(RootLogger) ? @name : @parent.full_name + "." + @name
-      @effective_level = level.nil? ? @parent.effective_level : level
-    end
-
-    # Adds an appender to this logger.
-    #
-    # @param [Log4Ruby::Appender] appender the appender to add.
-    def add_appender(appender)
-      @appenders << appender
-    end
-
-    # Shuts down this logger. It will no longer dispatch logs to its appenders, not will it forward logs to its parent.
-    #
-    # @return [TrueClass] Always true.
-    def close
-      @closed = true
-    end
-
-    # Check if this logger is closed.
-    #
-    # @return [TrueClass, FalseClass] true if the logger is closed.
-    def closed?
-      @closed
-    end
-
-    # Gets a child logger with the specified name. If the create flag is true, it will create a new logger
-    # with this name.
-    #
-    # @param [String] name the name of the logger.
-    # @param [TrueClass, FalseClass] create if true, create a logger if it does not exist.
-    def get_logger(name, create = false)
-      if @children.has_key?(name)
-        @children[name]
-      elsif create
-        @children[name] = Logger.new(name, self)
-      else
-        raise Log4Ruby::LoggerNotFoundError.new("Logger '#{name}' does not exist under '#@full_name'!")
-      end
-    end
-
-    # Update this logger's level. This will update the effective level for all child loggers too (except for the ones
-    # that have had their level explicitly set.
-    #
-    # @param [Log4Ruby::Level] new_level the new level.
-    def set_level(new_level)
-      @level = new_level
-      @effective_level = new_level
-      @children.each_value { |logger| logger.update_effective_level(new_level) }
-    end
-
-    # Returns the full name of the logger.
-    #
-    # @return [String] the full name of the logger.
-    def to_s
-      @full_name
-    end
-
-    protected
-
-    # Updates the effective level for this logger. This method is called internally when a logger's level is updated
-    # and should not be invoked directly.
-    #
-    # @param [Log4Ruby::Level] new_level the new effective level.
-    def update_effective_level(new_level)
-      if @level.nil?
-        @effective_level = new_level
-        @children.each_value { |logger| logger.update_effective_level(new_level) }
-      end
-    end
-
-    # Process the log message.
-    #
-    # @param [Log4Ruby::Log] log the log item to process. Does nothing if the log does not meet this logger's
-    # threshold level.
-    def process_log(log)
-      return if self.closed?
-      return if log[:level] < self.effective_level
-      # Forward to each appender. Once done, send to the parent.
-      @appenders.each { |appender| appender.process_log(log) }
-      @parent.process_log(log) if @use_parent_appenders
-    end
-
-  end
-
-  # Represents the root logger. This logger is similar to any other logger, except since it does not have a parent
-  # logger, it does not forward logs.
-  class RootLogger < Logger
-
-    include Singleton
-
-    # New root logger. The root logger is the parent of all loggers in the system.
-    def initialize
-      @full_name = @name = "Root"
-      @parent = nil
-      @effective_level = @level = Log4Ruby::Level::DEBUG
-      @appenders = []
-      @children = {}
-      @use_parent_appenders = false
-    end
-
-    # Override to do nothing. Since the root doesn't have a parent.
-    #
-    # @param [Log4Ruby::Level] new_level ignored, since the root doesn't have a parent.
-    def use_parent_appenders=(new_level)
-    end
-
-  end
-
+#
+# 22 Jul 2012
+#
+
+require "singleton"
+
+module Log4Ruby
+
+  # Represents a logger.
+  # Loggers are arranged into a tree, where each logger, after having dispatched the log to its appenders,
+  # forwards the log to its parents too.
+  class Logger
+
+    # The effective level of this logger. This will be the parent's effective level if a level has not been
+    # explicitly set for this logger.
+    attr_reader :effective_level
+    # The full name of this logger.
+    attr_reader :full_name
+    # The name of this logger.
+    attr_reader :name
+    # True to use parent appenders (the default) false to use only this logger's appenders.
+    attr_writer :use_parent_appenders
+
+    # Creates a new logger. Users should not use this method, and should use the Log4Ruby.get_logger method.
+    #
+    # @param [String] name the name for this logger.
+    # @param [Log4Ruby::Logger] parent the parent to this logger. If set to nil, becomes the child of the root logger.
+    # @param [Log4Ruby::Level] level the level of this logger. If set to nil, uses the parent's effective level
+    # (defaults to DEBUG for the root logger).
+    # @param [Array] appenders a list of appenders this logger will use.
+    def initialize(name, parent = nil, level = nil, appenders = [])
+      @name = name
+      @parent = parent.nil? ? RootLogger.instance : parent
+      @level = level
+      @appenders = appenders
+      @children = {}
+      @closed = false
+
+      @use_parent_appenders = true
+      @full_name = @parent.kind_of?(RootLogger) ? @name : @parent.full_name + "." + @name
+      @effective_level = level.nil? ? @parent.effective_level : level
+    end
+
+    # Adds an appender to this logger.
+    #
+    # @param [Log4Ruby::Appender] appender the appender to add.
+    def add_appender(appender)
+      @appenders << appender
+    end
+
+    # Shuts down this logger. It will no longer dispatch logs to its appenders, not will it forward logs to its parent.
+    #
+    # @return [TrueClass] Always true.
+    def close
+      @closed = true
+    end
+
+    # Check if this logger is closed.
+    #
+    # @return [TrueClass, FalseClass] true if the logger is closed.
+    def closed?
+      @closed
+    end
+
+    # Gets a child logger with the specified name. If the create flag is true, it will create a new logger
+    # with this name.
+    #
+    # @param [String] name the name of the logger.
+    # @param [TrueClass, FalseClass] create if true, create a logger if it does not exist.
+    def get_logger(name, create = false)
+      if @children.has_key?(name)
+        @children[name]
+      elsif create
+        @children[name] = Logger.new(name, self)
+      else
+        raise Log4Ruby::LoggerNotFoundError.new("Logger '#{name}' does not exist under '#@full_name'!")
+      end
+    end
+
+    # Update this logger's level. This will update the effective level for all child loggers too (except for the ones
+    # that have had their level explicitly set.
+    #
+    # @param [Log4Ruby::Level] new_level the new level.
+    def set_level(new_level)
+      @level = new_level
+      @effective_level = new_level
+      @children.each_value { |logger| logger.update_effective_level(new_level) }
+    end
+
+    # Returns the full name of the logger.
+    #
+    # @return [String] the full name of the logger.
+    def to_s
+      @full_name
+    end
+
+    protected
+
+    # Updates the effective level for this logger. This method is called internally when a logger's level is updated
+    # and should not be invoked directly.
+    #
+    # @param [Log4Ruby::Level] new_level the new effective level.
+    def update_effective_level(new_level)
+      if @level.nil?
+        @effective_level = new_level
+        @children.each_value { |logger| logger.update_effective_level(new_level) }
+      end
+    end
+
+    # Process the log message.
+    #
+    # @param [Log4Ruby::Log] log the log item to process. Does nothing if the log does not meet this logger's
+    # threshold level.
+    def process_log(log)
+      return if self.closed?
+      return if log[:level] < self.effective_level
+      # Forward to each appender. Once done, send to the parent.
+      @appenders.each { |appender| appender.process_log(log) }
+      @parent.process_log(log) if @use_parent_appenders
+    end
+
+  end
+
+  # Represents the root logger. This logger is similar to any other logger, except since it does not have a parent
+  # logger, it does not forward logs.
+  class RootLogger < Logger
+
+    include Singleton
+
+    # New root logger. The root logger is the parent of all loggers in the system.
+    def initialize
+      @full_name = @name = "Root"
+      @parent = nil
+      @effective_level = @level = Log4Ruby::Level::DEBUG
+      @appenders = []
+      @children = {}
+      @use_parent_appenders = false
+    end
+
+    # Override to do nothing. Since the root doesn't have a parent.
+    #
+    # @param [Log4Ruby::Level] new_level ignored, since the root doesn't have a parent.
+    def use_parent_appenders=(new_level)
+    end
+
+  end
+
 end

data/lib/log4ruby/version.rb

@@ -1,9 +1,9 @@
-#
-# 21 Jul 2012
-#
-
-module Log4Ruby
-
-  VERSION = "0.0.3"
-
+#
+# 21 Jul 2012
+#
+
+module Log4Ruby
+
+  VERSION = "0.0.4"
+
 end

data/lib/sample.rb

@@ -0,0 +1,82 @@
+#
+# 22 Jul 2012
+#
+
+$LOAD_PATH << "."
+
+require "log4ruby"
+require "log4ruby/appenders/console_appender"
+require "log4ruby/appenders/file_appender"
+require "log4ruby/formatters/pattern_formatter"
+
+# The pattern formatter, with a custom parameter formatter for the timestamp and the logger.
+formatter = Log4Ruby::PatternFormatter.new("[%s] %7s - %s : %s (%s)\n", [:timestamp, :level, :logger, :message, :extra])
+formatter.add_parameter_formatter(:logger, Log4Ruby::ParameterFormatters.logger_formatter(1))
+formatter.add_parameter_formatter(:timestamp, Log4Ruby::ParameterFormatters.timestamp_formatter("%Y-%m-%d %H:%M:%S.%L"))
+# Console appender for printing to stdout.
+console_appender = Log4Ruby::ConsoleAppender.new(Log4Ruby::Level::ALL, :target => :stdout)
+# Rolling file appender
+file_appender = Log4Ruby::FileAppender.new(Log4Ruby::Level::ALL, :roll_type => :dont_roll,
+                                           :directory => "../logs", :prefix => "TestLogger")
+size_appender = Log4Ruby::FileAppender.new(Log4Ruby::Level::ALL, :formatter => formatter, :roll_type => :roll_using_size,
+                                           :directory => "../logs", :prefix => "TestLoggerSize", :max_size => 1024)
+date_appender = Log4Ruby::FileAppender.new(Log4Ruby::Level::ALL, :formatter => formatter, :roll_type => :roll_using_date,
+                                           :directory => "../logs", :prefix => "TestLoggerDate", :frequency => :hourly)
+
+# XML formatter.
+indent = "  "
+log_start_element = "#{indent}<log>"
+timestamp_element = "#{indent * 2}<timestamp>%s</timestamp>"
+level_element = "#{indent * 2}<level>%s</level>"
+logger_element = "#{indent * 2}<logger>%s</logger>"
+message_element = "#{indent * 2}<message>%s</message>"
+log_end_element = "#{indent}</log>"
+format_string = [log_start_element, timestamp_element, level_element, logger_element, message_element, log_end_element].join("\n")
+xml_formatter = Log4Ruby::PatternFormatter.new("#{format_string}\n", [:timestamp, :level, :logger, :message])
+# XML appender (with custom header and footer methods)
+xml_appender = Log4Ruby::FileAppender.new(Log4Ruby::Level::ALL, :formatter => xml_formatter, :roll_type => :dont_roll,
+                                          :directory => "../logs", :prefix => "TestLogger", :suffix => "xml")
+
+# Custom header / footer methods.
+xml_appender.header { |stream| stream.write("<logs>\n") }
+xml_appender.footer { |stream| stream.write("</logs>\n") }
+
+# Register a custom level FINER, that is between TRACE and FINE
+Log4Ruby::Level.register("FINER", 150.0)
+
+# The loggers.
+# TestLogger is a child of the Log4Ruby logger. So even though the ConsoleAppender is added to the Log4Ruby logger,
+# logs created using TestLogger are printed on the console (upto the level DEBUG). This is because TestLogger will
+# forward logs to its parent's appenders. This behaviour can be turned off using the use_parent_appenders flag.
+log4ruby_logger = Log4Ruby.get_logger("Log4Ruby")
+log4ruby_logger.set_level(Log4Ruby::Level::DEBUG)
+log4ruby_logger.add_appender(console_appender)
+test_logger = Log4Ruby.get_logger("Log4Ruby::TestLogger")
+test_logger.add_appender(xml_appender)
+test_logger.add_appender(file_appender)
+test_logger.add_appender(size_appender)
+test_logger.add_appender(date_appender)
+
+# Additionally, the test logger will inherit the effective level of its parent, unless explicitly overridden.
+puts "Inherited level is #{test_logger.effective_level}"
+puts "Logger will print TRACE? : #{test_logger.trace?}"
+puts "Logger will print FINER? : #{test_logger.finer?}"
+puts "Logger will print FINE?  : #{test_logger.fine?}"
+test_logger.set_level(Log4Ruby::Level::FINER)
+puts "Updated level to #{test_logger.effective_level}."
+puts "Logger will print TRACE? : #{test_logger.trace?}"
+puts "Logger will print FINER? : #{test_logger.finer?}"
+puts "Logger will print FINE?  : #{test_logger.fine?}"
+
+# Logs are created by directly invoking the required methods (these are dynamically created on the Logger class).
+# The log methods can also take an optional hash of attributes. The formatter can then be configured to print those
+# values.
+test_logger.trace("Test!", :extra => "Trace")
+test_logger.finer("Test!", :extra => "Finer")
+test_logger.fine("Test!", :extra => "Fine")
+test_logger.debug("Test!", :extra => "Debug")
+test_logger.conf("Test!", :extra => "Conf")
+test_logger.info("Test!")
+test_logger.warn("Test!")
+test_logger.error("Test!")
+test_logger.fatal("Test!")

metadata

@@ -1,48 +1,34 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: log4ruby
-version: !ruby/object:Gem::Version 
-  hash: 25
+version: !ruby/object:Gem::Version
+  version: 0.0.4
   prerelease: 
-  segments: 
-  - 0
-  - 0
-  - 3
-  version: 0.0.3
 platform: ruby
-authors: 
+authors:
 - Suraj Vijayakumar
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2012-07-24 00:00:00 Z
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2012-07-26 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: options-arg
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  requirement: &7797456 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 29
-        segments: 
-        - 0
-        - 0
-        - 1
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
         version: 0.0.1
   type: :runtime
-  version_requirements: *id001
+  prerelease: false
+  version_requirements: *7797456
 description: A logging system for Ruby applications inspired by Java's logging API.
-email: 
+email:
 - vijayakumar.suraj@gmail.com
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
 - lib/log4ruby/appender.rb
 - lib/log4ruby/appenders/console_appender.rb
 - lib/log4ruby/appenders/file_appender.rb
@@ -50,47 +36,36 @@ files:
 - lib/log4ruby/appenders/stream_appender.rb
 - lib/log4ruby/exceptions.rb
 - lib/log4ruby/formatter.rb
+- lib/log4ruby/formatters/default_formatter.rb
 - lib/log4ruby/formatters/pattern_formatter.rb
 - lib/log4ruby/level.rb
 - lib/log4ruby/log.rb
 - lib/log4ruby/logger.rb
 - lib/log4ruby/version.rb
 - lib/log4ruby.rb
-- lib/tests.rb
+- lib/sample.rb
 homepage: 
 licenses: []
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 51
-      segments: 
-      - 1
-      - 9
-      - 0
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
       version: 1.9.0
-required_rubygems_version: !ruby/object:Gem::Requirement 
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 1.7.2
 signing_key: 
 specification_version: 3
 summary: A simple and customizable logging system inspired by Java logging API.
 test_files: []
-

data/lib/tests.rb

@@ -1,49 +0,0 @@
-#
-# 22 Jul 2012
-#
-
-$LOAD_PATH << "."
-
-require "log4ruby"
-require "log4ruby/appenders/console_appender"
-require "log4ruby/appenders/file_appender"
-require "log4ruby/formatters/pattern_formatter"
-
-# The pattern formatter, with a custom parameter formatter for the timestamp.
-formatter = Log4Ruby::PatternFormatter.new("[%s] %7s - %s : %s\n", [:timestamp, :level, :logger, :message])
-formatter.add_parameter_formatter(:logger, Log4Ruby::ParameterFormatters.logger_formatter(1))
-formatter.add_parameter_formatter(:timestamp, Log4Ruby::ParameterFormatters.timestamp_formatter("%Y-%m-%d %H:%M:%S.%L"))
-# Stream appender for printing to stdout.
-console_appender = Log4Ruby::ConsoleAppender.new(Log4Ruby::Level::ALL, formatter, :stdout)
-# Rolling file appender
-file_appender = Log4Ruby::FileAppender.new(Log4Ruby::Level::ALL, formatter, :roll_type => :dont_roll,
-                                           :directory => "../logs", :prefix => "TestLogger")
-size_appender = Log4Ruby::FileAppender.new(Log4Ruby::Level::ALL, formatter, :roll_type => :roll_using_size,
-                                           :directory => "../logs", :prefix => "TestLoggerSize", :max_size => 1024)
-date_appender = Log4Ruby::FileAppender.new(Log4Ruby::Level::ALL, formatter, :roll_type => :roll_using_date,
-                                           :directory => "../logs", :prefix => "TestLoggerDate", :frequency => :hourly)
-
-# Register a custom level FINER, that is between TRACE and FINE
-Log4Ruby::Level.register("FINER", 150.0)
-
-# The logger.
-logger = Log4Ruby.get_logger("Log4Ruby::TestLogger")
-logger.set_level(Log4Ruby::Level::FINER)
-logger.add_appender(console_appender)
-logger.add_appender(file_appender)
-logger.add_appender(size_appender)
-logger.add_appender(date_appender)
-
-puts "Logger will print TRACE? : #{logger.trace?}"
-puts "Logger will print FINER? : #{logger.finer?}"
-puts "Logger will print FINE?  : #{logger.fine?}"
-
-logger.trace("Test!")
-logger.finer("Test!")
-logger.fine("Test!")
-logger.debug("Test!")
-logger.conf("Test!")
-logger.info("Test!")
-logger.warn("Test!")
-logger.error("Test!")
-logger.fatal("Test!")