log4ruby 0.0.1

data/lib/log4ruby.rb

@@ -0,0 +1,36 @@
+#
+# 21 Jul 2012
+#
+
+require "options_arg"
+
+require "log4ruby/appender"
+require "log4ruby/exceptions"
+require "log4ruby/formatter"
+require "log4ruby/log"
+require "log4ruby/logger"
+
+require "log4ruby/level"
+
+module Log4Ruby
+
+  @@loggers = {}
+
+  # Get a logger with the specified name. The name can be a '.' separated string or a "::" separated string.
+  # Loggers are created only if required.
+  #
+  # @param [String] name the name of the logger to get.
+  #
+  # @return [Log4Ruby::Logger] the logger.
+  def self.get_logger(name)
+    # Return a logger if it had been created earlier.
+    return @@loggers[name] if @@loggers.has_key?(name)
+    # Otherwise, create it.
+    parts = name.index("::") ? name.split("::") : name.split(".")
+    logger = RootLogger.instance
+    parts.each { |part| logger = logger.get_logger(part, true) }
+    # The logger.
+    @@loggers[name] = logger
+  end
+
+end

data/lib/log4ruby/appender.rb

@@ -0,0 +1,42 @@
+#
+# 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
+    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
+
+end

data/lib/log4ruby/appenders/nil_appender.rb

@@ -0,0 +1,16 @@
+#
+# 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
+
+end

data/lib/log4ruby/appenders/stream_appender.rb

@@ -0,0 +1,31 @@
+#
+# 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

data/lib/log4ruby/exceptions.rb

@@ -0,0 +1,10 @@
+#
+# 22 Jul 2012
+#
+
+module Log4Ruby
+
+  class LoggerNotFoundError < Exception
+  end
+
+end

data/lib/log4ruby/formatter.rb

@@ -0,0 +1,20 @@
+#
+# 21 Jul 2012
+#
+
+module Log4Ruby
+
+  # Base class for all formatters.
+  class Formatter
+
+    # Format a log item.
+    #
+    # @param [Log4Ruby::Log] log
+    #
+    # @return [String] the fully formatted log message.
+    def format(log)
+    end
+
+  end
+
+end

data/lib/log4ruby/formatters/pattern_formatter.rb

@@ -0,0 +1,51 @@
+#
+# 21 Jul 2012
+#
+
+require "log4ruby/formatter"
+require "log4ruby/log"
+
+module Log4Ruby
+
+  class PatternFormatter
+
+    # New pattern formatted.
+    #
+    # @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] custom_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, custom_formatters = {})
+      @format_string = get_option(options, :format_string)
+      @subst_array = get_option(options, :subst_array)
+      @custom_formatters = get_option(options, :custom_formatters)
+    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]
+        @custom_formatters.has_key?(parameter) ? @custom_formatters[parameter].call(value) : value.to_s
+      end
+      # Substitute into the format string.
+      @format_string % parameters
+    end
+
+  end
+
+end

data/lib/log4ruby/level.rb

@@ -0,0 +1,94 @@
+#
+# 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 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/log.rb

@@ -0,0 +1,36 @@
+#
+# 21 Jul 2012
+#
+
+module Log4Ruby
+
+  # Represents a log item.
+  class Log
+
+    attr_reader :parameters
+
+    # A hash containing all the information in this log.
+    # A message, level and logger are the only mandatory parameters.
+    def initialize(parameters = {})
+      @message = get_option(parameters, :message, true)
+      @level = get_option(parameters, :level, true)
+      @logger = get_option(parameters, :logger, true)
+      @timestamp = set_option(parameters, :timestamp, Time.now, true)
+
+      @parameters = parameters
+      @parameters[:logger_name] = @logger.name
+      @parameters[:full_logger_name] = @logger.full_name
+    end
+
+    # Get the specified parameter.
+    #
+    # @param [Symbol] parameter the parameter to get.
+    #
+    # @return [Object] the parameter's value, or nil if the parameter did not exist.
+    def [](parameter)
+      @parameters[parameter]
+    end
+
+  end
+
+end

data/lib/log4ruby/logger.rb

@@ -0,0 +1,127 @@
+#
+# 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 = {}
+
+      @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
+
+    # 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
+
+    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 log[:level] < @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
+
+    private
+
+  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

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

data/lib/options_arg.rb

@@ -0,0 +1,66 @@
+#
+# 16 Jul 2012
+#
+
+# Provides a few methods to work with hashes.
+module Kernel
+
+  # Raised if a required option has not been set.
+  class OptionNotSetError < Exception
+  end
+
+  private
+
+  # Get a value from the specified hash.
+  #
+  # @param [Hash] options the hash.
+  # @param [Symbol] key the key whose value is required.
+  # @param [TrueClass, FalseClass] required flag to indicate if it is an error if the key does not exist.
+  # @param [Object] default the default value if the key does not exist. Only used if 'required' is false.
+  #
+  # @return [Object] the value from the hash, or the default value.
+  def get_option(options, key, required = false, default = nil)
+    if options.has_key?(key)
+      options[key]
+    elsif required
+      raise OptionNotSetError.new("Option '#{key}' has not been set!")
+    else
+      default
+    end
+  end
+
+  # Pops (delete) a value from the specified hash.
+  #
+  # @param [Hash] options the hash.
+  # @param [Symbol] key the key whose value is required.
+  # @param [TrueClass, FalseClass] required flag to indicate if it is an error if the key does not exist.
+  # @param [Object] default the default value if the key does not exist. Only used if 'required' is false.
+  #
+  # @return [Object] the value from the hash, or the default value.
+  def pop_option(options, key, required = false, default = nil)
+    if options.has_key?(key)
+      options.delete(key)
+    elsif required
+      raise OptionNotSetError.new("Option '#{key}' has not been set!")
+    else
+      default
+    end
+  end
+
+  # Sets a value in the specified hash.
+  #
+  # @param [Hash] options the hash.
+  # @param [Symbol] key the key whose value is to be set.
+  # @param [Object] value the value to set.
+  # @param [TrueClass, FalseClass] overwrite flag to indicate if existing values should be overwritten.
+  #
+  # @return [Object] the value in the hash at the end of the operation.
+  def set_option(options, key, value, overwrite)
+    if not options.has_key?(key) or overwrite
+      options[key] = value
+    end
+    # Return whatever is in the hash now.
+    options[key]
+  end
+
+end

data/lib/tests.rb

@@ -0,0 +1,38 @@
+#
+# 22 Jul 2012
+#
+
+$LOAD_PATH << "."
+
+require "log4ruby"
+require "log4ruby/appenders/stream_appender"
+require "log4ruby/formatters/pattern_formatter"
+
+# The pattern formatter, with a custom parameter formatter for the timestamp.
+timestamp_formatter = Proc.new { |timestamp| timestamp.strftime("%Y-%m-%d %H:%M:%S.%L") }
+formatter = Log4Ruby::PatternFormatter.new("[%s] %7s - %s : %s\n", [:timestamp, :level, :full_logger_name, :message],
+                                           {:timestamp => timestamp_formatter})
+# Stream appender for printing to stdout.
+console_appender = Log4Ruby::StreamAppender.new(Log4Ruby::Level::ALL, formatter, $stdout)
+
+# 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)
+
+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!")

metadata

@@ -0,0 +1,58 @@
+--- !ruby/object:Gem::Specification
+name: log4ruby
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Suraj Vijayakumar
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-07-22 00:00:00.000000000 Z
+dependencies: []
+description: A logging system for Ruby applications inspired by Java's logging API.
+email:
+- vijayakumar.suraj@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/log4ruby/appender.rb
+- lib/log4ruby/appenders/nil_appender.rb
+- lib/log4ruby/appenders/stream_appender.rb
+- lib/log4ruby/exceptions.rb
+- lib/log4ruby/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/options_arg.rb
+- lib/tests.rb
+homepage: 
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: A simple and customizable logging system inspired by Java logging API.
+test_files: []