log4ruby 0.0.2 → 0.0.3

data/lib/log4ruby/appender.rb

@@ -17,6 +17,21 @@ module Log4Ruby
     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.

data/lib/log4ruby/appenders/console_appender.rb

@@ -0,0 +1,24 @@
+#
+# 24 Jul 2012
+#
+
+require "log4ruby/appenders/stream_appender"
+
+module Log4Ruby
+
+  # Sends console messages to either stdout or stderr.
+  class ConsoleAppender < Log4Ruby::StreamAppender
+
+    TARGETS = {:stdout => $stdout, :stderr => $stderr}
+
+    # New console appender.
+    #
+    # @param [Symbol] target either stdout or stderr.
+    def initialize(level, formatter, target = :stdout)
+      raise ArgumentError.new("Invalid target '#{target}'. Must be either 'stdout' or 'stderr'.") unless TARGETS.has_key?(target)
+      super(level, formatter, TARGETS[target])
+    end
+
+  end
+
+end

data/lib/log4ruby/appenders/file_appender.rb

@@ -0,0 +1,164 @@
+#
+# 24 Jul 2012
+#
+
+require "date"
+
+require "log4ruby/appenders/stream_appender"
+
+module Log4Ruby
+
+  class DateRollers
+
+    HOURLY = Proc.new { |file_time| Time.now.hour != file_time.hour }
+
+    DAILY = Proc.new { |file_time| Time.now.day != file_time.day }
+
+    WEEKLY = Proc.new { |file_time| DateTime.now.cweek != DateTime.parse(file_time.to_s).cweek }
+
+    MONTHLY = Proc.new { |file_time| Time.now.month > file_time.month }
+
+    YEARLY = Proc.new { |file_time| Time.now.year > file_time.year }
+
+  end
+
+  # Customizable file appender to log to a file.
+  class FileAppender < Log4Ruby::StreamAppender
+
+    DATE_ROLLERS = {:hourly => DateRollers::HOURLY, :daily => DateRollers::DAILY,
+                    :weekly => DateRollers::WEEKLY, :monthly => DateRollers::MONTHLY,
+                    :yearly => DateRollers::YEARLY}
+
+    # New stream appender.
+    #
+    # @param [Hash] options configuration hash. Supports the following parameters.
+    #  :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'
+    #  :max_files - the maximum number of files to keep. Defaults to 5.
+    #  :roll_type - the type of rolling required. Supports the following
+    #     :dont_roll - the default type. Only one file is created.
+    #     :roll_using_size - rolls files using the file's size.
+    #     :roll_using_date - rolls files using the file's create date.
+    #
+    # Configuration parameters specific to rollers.
+    # dont_roll:
+    #   :truncate - if true (the default), contents of the file are deleted before logging begins.
+    #
+    # roll_using_size:
+    #   :max_size - the maximum allowed size for a log file (in bytes - default is 102400 bytes).
+    #
+    # 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)
+
+      @directory = get_option(options, :directory, false, "./")
+      @prefix = get_option(options, :prefix, true)
+      @suffix = get_option(options, :suffix, false, "log")
+      @max_files = get_option(options, :max_files, false, 5)
+      @type = get_option(options, :roll_type, false, :dont_roll)
+
+      type_method = "initialize_#@type"
+      raise ArgumentError.new("Unrecognized type '#@type'!") unless respond_to?(type_method, true)
+      send(type_method, options)
+    end
+
+    private
+
+    # Creates a new file for logging into.
+    def create_file
+      @counter = @counter < @max_files ? @counter + 1 : 1
+
+      # The create timestamp is fussy.
+      # So first, delete any existing files.
+      # Then create a file with a temporary name and rename (i.e. move) it to the required file name.
+      # Finally open this file for use.
+      # This way the create date time is correct (i.e. the actual time the file was created).
+      @stream.close unless (@stream.nil? or @stream.closed?)
+      file_path = File.expand_path("#@prefix.#@counter.#@suffix", @directory)
+      file_path_temp = File.expand_path("#@prefix.#@counter.#@suffix.temp", @directory)
+      FileUtils.rm(file_path) if File.exist?(file_path)
+      File.new(file_path_temp, "w").close
+      FileUtils.mv(file_path_temp, file_path)
+      @stream = File.new(file_path, "w")
+    end
+
+    # Initialises this appender to not roll.
+    #
+    # @param [Hash] options configuration options.
+    def initialize_dont_roll(options)
+      mode = get_option(options, :truncate, false, true) ? "w" : "a"
+      FileUtils.mkdir(@directory) unless File.exist?(@directory)
+      @stream = File.open(File.expand_path("#@prefix.#@suffix", @directory), mode)
+    end
+
+    # Initialises this appender to roll using the date of the file.
+    #
+    # @param [Hash] options configuration options.
+    def initialize_roll_using_date(options)
+      frequency = get_option(options, :frequency, false, :daily)
+      raise ArgumentError.new("Unrecognized frequency '#{frequency}'!") unless DATE_ROLLERS.has_key?(frequency)
+      @roller = DATE_ROLLERS[frequency]
+      # @stream is set to the latest file.
+      latest_file
+      # 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)
+      end
+    end
+
+    # Initialises this appender to roll using the size of the file.
+    #
+    # @param [Hash] options configuration options.
+    def initialize_roll_using_size(options)
+      @max_size = get_option(options, :max_size, false, 102400)
+      # @stream is set to the latest file.
+      latest_file
+      # 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)
+      end
+    end
+
+    # Sets @stream to the most recent file (if it exists). Otherwise creates a new file.
+    # Only required if @stream is nil. Otherwise it returns immediately.
+    def latest_file
+      FileUtils.mkdir(@directory) unless File.exist?(@directory)
+      pattern = File.expand_path("#@prefix.*.#@suffix", @directory)
+      files = Dir.glob(pattern).sort { |f1, f2| File.mtime(f2) <=> File.mtime(f1) }
+      latest_file = files[0]
+
+      if latest_file.nil?
+        @counter = 0
+        create_file
+      else
+        @stream = File.open(latest_file, "a")
+        @counter = Integer(latest_file.match(/#@prefix\.(\d+)\.#@suffix/)[1])
+      end
+    end
+
+    # Rolls the current file if the create date time is old enough.
+    def roll_using_date
+      return unless @roller.call(@stream.ctime)
+
+      create_file
+    end
+
+    # Rolls the current file if the size is greater than the maximum size.
+    def roll_using_size
+      return if @stream.stat.size < @max_size
+
+      create_file
+    end
+
+  end
+
+end

data/lib/log4ruby/level.rb

@@ -23,6 +23,7 @@ module Log4Ruby
       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

data/lib/log4ruby/logger.rb

@@ -34,6 +34,7 @@ module Log4Ruby
       @level = level
       @appenders = appenders
       @children = {}
+      @closed = false
 
       @use_parent_appenders = true
       @full_name = @parent.kind_of?(RootLogger) ? @name : @parent.full_name + "." + @name
@@ -47,6 +48,20 @@ module Log4Ruby
       @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.
     #
@@ -97,7 +112,8 @@ module Log4Ruby
     # @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
+      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

data/lib/log4ruby/version.rb

@@ -4,6 +4,6 @@
 
 module Log4Ruby
 
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 
 end

data/lib/tests.rb

@@ -5,7 +5,8 @@
 $LOAD_PATH << "."
 
 require "log4ruby"
-require "log4ruby/appenders/stream_appender"
+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.
@@ -13,7 +14,14 @@ formatter = Log4Ruby::PatternFormatter.new("[%s] %7s - %s : %s\n", [:timestamp,
 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::StreamAppender.new(Log4Ruby::Level::ALL, formatter, $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)
@@ -22,6 +30,9 @@ Log4Ruby::Level.register("FINER", 150.0)
 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?}"
@@ -35,4 +46,4 @@ logger.conf("Test!")
 logger.info("Test!")
 logger.warn("Test!")
 logger.error("Test!")
-logger.fatal("Test!")
+logger.fatal("Test!")

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: log4ruby
 version: !ruby/object:Gem::Version 
-  hash: 27
+  hash: 25
   prerelease: 
   segments: 
   - 0
   - 0
-  - 2
-  version: 0.0.2
+  - 3
+  version: 0.0.3
 platform: ruby
 authors: 
 - Suraj Vijayakumar
@@ -44,6 +44,8 @@ extra_rdoc_files: []
 
 files: 
 - lib/log4ruby/appender.rb
+- lib/log4ruby/appenders/console_appender.rb
+- lib/log4ruby/appenders/file_appender.rb
 - lib/log4ruby/appenders/nil_appender.rb
 - lib/log4ruby/appenders/stream_appender.rb
 - lib/log4ruby/exceptions.rb
@@ -52,7 +54,6 @@ files:
 - lib/log4ruby/level.rb
 - lib/log4ruby/log.rb
 - lib/log4ruby/logger.rb
-- lib/log4ruby/rolling_file.rb
 - lib/log4ruby/version.rb
 - lib/log4ruby.rb
 - lib/tests.rb
@@ -69,10 +70,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
+      hash: 51
       segments: 
+      - 1
+      - 9
       - 0
-      version: "0"
+      version: 1.9.0
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 

data/lib/log4ruby/rolling_file.rb

@@ -1,26 +0,0 @@
-#
-# 23 Jul 2012
-#
-
-module Log4Ruby
-
-  class RollingFile
-
-    # New rolling file with the specified prefix.
-    #
-    # @param [String] prefix the prefix for all the files that will be created.
-    def initialize(prefix)
-      @prefix = prefix
-    end
-
-  end
-
-  class TimedRollingFile < RollingFile
-
-    # New timed rolling file that will roll over to a new file when the specified time expires.
-    def initialize(prefix, time_to_roll)
-    end
-
-  end
-
-end