logger 1.2.8.1 → 1.4.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fca3ed305eb759ed28a0ea917d653feee81fc4d399a53a44e6649d8e8389defb
-  data.tar.gz: 90cef9d07cb58cb5049c1a869ae56ec609e0dfd1befcac6053b97602e11ee609
+  metadata.gz: be49be41055335fa90e79c26a714b7176077de04b414def791b1a9524169ad80
+  data.tar.gz: f064246f7c9e483f96e9838ace1d079ce0d9acea770eb68d5a492a792157bb83
 SHA512:
-  metadata.gz: c2c96afb68a6e3a22e53673119f673bd6490d6d1c5c184da06677633648c0e86ce6c7eaacbb4dca55c4d3c800ea8d7708c55235a854987c98ed3f20feee185f9
-  data.tar.gz: c5e39c441722c99cd6fee091939303d22448a329543699b1deac011d3500f3cf939987ff6c4c64db1cff526a746e1e6050f9af801f057f3aca5181ea734599fa
+  metadata.gz: 8dc3387289106d3f98eda8384351d9486b8ad5bb21e5c58a3932595b101705600b1b66c64666eabab90a11f1d90a4b7f01e6f0ce658249bfb9ede51d76414ef4
+  data.tar.gz: 693e411b78fc95e47d008b3ced6247606ebb641f7a17368321e8e0002fa450694267794a620fc76f949ac9cf2a7e5ac8b891416d7d4accb738f8c2c228421388

data/lib/logger.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 # logger.rb - simple logging utility
 # Copyright (C) 2000-2003, 2005, 2008, 2011  NAKAMURA, Hiroshi <nahi@ruby-lang.org>.
 #
@@ -7,47 +8,48 @@
 #   license; either the dual license version in 2003, or any later version.
 # Revision:: $Id$
 #
-# See Logger for documentation.
-
+# A simple system for logging messages.  See Logger for more documentation.
 
 require 'monitor'
 
+require_relative 'logger/version'
+require_relative 'logger/formatter'
+require_relative 'logger/log_device'
+require_relative 'logger/severity'
+require_relative 'logger/errors'
 
 # == Description
 #
 # The Logger class provides a simple but sophisticated logging utility that
-# anyone can use because it's included in the Ruby 1.8.x standard library.
-#
-# The HOWTOs below give a code-based overview of Logger's usage, but the basic
-# concept is as follows.  You create a Logger object (output to a file or
-# elsewhere), and use it to log messages.  The messages will have varying
-# levels (+info+, +error+, etc), reflecting their varying importance.  The
-# levels, and their meanings, are:
-#
-# +FATAL+:: an unhandleable error that results in a program crash
-# +ERROR+:: a handleable error condition
-# +WARN+::  a warning
-# +INFO+::  generic (useful) information about system operation
-# +DEBUG+:: low-level information for developers
-#
-# So each message has a level, and the Logger itself has a level, which acts
-# as a filter, so you can control the amount of information emitted from the
-# logger without having to remove actual messages.
-#
-# For instance, in a production system, you may have your logger(s) set to
-# +INFO+ (or +WARN+ if you don't want the log files growing large with
-# repetitive information).  When you are developing it, though, you probably
-# want to know about the program's internal state, and would set them to
+# you can use to output messages.
+#
+# The messages have associated levels, such as +INFO+ or +ERROR+ that indicate
+# their importance.  You can then give the Logger a level, and only messages
+# at that level or higher will be printed.
+#
+# The levels are:
+#
+# +UNKNOWN+:: An unknown message that should always be logged.
+# +FATAL+:: An unhandleable error that results in a program crash.
+# +ERROR+:: A handleable error condition.
+# +WARN+::  A warning.
+# +INFO+::  Generic (useful) information about system operation.
+# +DEBUG+:: Low-level information for developers.
+#
+# For instance, in a production system, you may have your Logger set to
+# +INFO+ or even +WARN+.
+# When you are developing the system, however, you probably
+# want to know about the program's internal state, and would set the Logger to
 # +DEBUG+.
 #
-# **Note**: Logger does not escape or sanitize any messages passed to it.
+# *Note*: Logger does not escape or sanitize any messages passed to it.
 # Developers should be aware of when potentially malicious data (user-input)
 # is passed to Logger, and manually escape the untrusted data:
 #
 #   logger.info("User-input: #{input.dump}")
 #   logger.info("User-input: %p" % input)
 #
-# You can use Logger#formatter= for escaping all data.
+# You can use #formatter= for escaping all data.
 #
 #   original_formatter = Logger::Formatter.new
 #   logger.formatter = proc { |severity, datetime, progname, msg|
@@ -57,24 +59,29 @@ require 'monitor'
 #
 # === Example
 #
-# A simple example demonstrates the above explanation:
+# This creates a Logger that outputs to the standard output stream, with a
+# level of +WARN+:
 #
-#   log = Logger.new(STDOUT)
-#   log.level = Logger::WARN
+#   require 'logger'
 #
-#   log.debug("Created logger")
-#   log.info("Program started")
-#   log.warn("Nothing to do!")
+#   logger = Logger.new(STDOUT)
+#   logger.level = Logger::WARN
+#
+#   logger.debug("Created logger")
+#   logger.info("Program started")
+#   logger.warn("Nothing to do!")
+#
+#   path = "a_non_existent_file"
 #
 #   begin
-#     File.each_line(path) do |line|
+#     File.foreach(path) do |line|
 #       unless line =~ /^(\w+) = (.*)$/
-#         log.error("Line in wrong format: #{line}")
+#         logger.error("Line in wrong format: #{line.chomp}")
 #       end
 #     end
 #   rescue => err
-#     log.fatal("Caught exception; exiting")
-#     log.fatal(err)
+#     logger.fatal("Caught exception; exiting")
+#     logger.fatal(err)
 #   end
 #
 # Because the Logger's level is set to +WARN+, only the warning, error, and
@@ -108,16 +115,16 @@ require 'monitor'
 # 3. Create a logger for the specified file.
 #
 #      file = File.open('foo.log', File::WRONLY | File::APPEND)
-#      # To create new (and to remove old) logfile, add File::CREAT like;
-#      #   file = open('foo.log', File::WRONLY | File::APPEND | File::CREAT)
+#      # To create new logfile, add File::CREAT like:
+#      # file = File.open('foo.log', File::WRONLY | File::APPEND | File::CREAT)
 #      logger = Logger.new(file)
 #
-# 4. Create a logger which ages logfile once it reaches a certain size.  Leave
-#    10 "old log files" and each file is about 1,024,000 bytes.
+# 4. Create a logger which ages the logfile once it reaches a certain size.
+#    Leave 10 "old" log files where each file is about 1,024,000 bytes.
 #
 #      logger = Logger.new('foo.log', 10, 1024000)
 #
-# 5. Create a logger which ages logfile daily/weekly/monthly.
+# 5. Create a logger which ages the logfile daily/weekly/monthly.
 #
 #      logger = Logger.new('foo.log', 'daily')
 #      logger = Logger.new('foo.log', 'weekly')
@@ -126,17 +133,17 @@ require 'monitor'
 # === How to log a message
 #
 # Notice the different methods (+fatal+, +error+, +info+) being used to log
-# messages of various levels.  Other methods in this family are +warn+ and
+# messages of various levels?  Other methods in this family are +warn+ and
 # +debug+.  +add+ is used below to log a message of an arbitrary (perhaps
 # dynamic) level.
 #
-# 1. Message in block.
+# 1. Message in a block.
 #
 #      logger.fatal { "Argument 'foo' not given." }
 #
 # 2. Message as a string.
 #
-#      logger.error "Argument #{ @foo } mismatch."
+#      logger.error "Argument #{@foo} mismatch."
 #
 # 3. With progname.
 #
@@ -146,6 +153,20 @@ require 'monitor'
 #
 #      logger.add(Logger::FATAL) { 'Fatal error!' }
 #
+# The block form allows you to create potentially complex log messages,
+# but to delay their evaluation until and unless the message is
+# logged.  For example, if we have the following:
+#
+#     logger.debug { "This is a " + potentially + " expensive operation" }
+#
+# If the logger's level is +INFO+ or higher, no debug messages will be logged,
+# and the entire block will not even be evaluated.  Compare to this:
+#
+#     logger.debug("This is a " + potentially + " expensive operation")
+#
+# Here, the string concatenation is done every time, even if the log
+# level is not set to show the debug message.
+#
 # === How to close a logger
 #
 #      logger.close
@@ -160,8 +181,20 @@ require 'monitor'
 #
 #      logger.level = Logger::INFO
 #
-#      DEBUG < INFO < WARN < ERROR < FATAL < UNKNOWN
+#      # DEBUG < INFO < WARN < ERROR < FATAL < UNKNOWN
+#
+# 3. Symbol or String (case insensitive)
+#
+#      logger.level = :info
+#      logger.level = 'INFO'
 #
+#      # :debug < :info < :warn < :error < :fatal < :unknown
+#
+# 4. Constructor
+#
+#      Logger.new(logdev, level: Logger::INFO)
+#      Logger.new(logdev, level: :info)
+#      Logger.new(logdev, level: 'INFO')
 #
 # == Format
 #
@@ -169,65 +202,101 @@ require 'monitor'
 # default.  The default format and a sample are shown below:
 #
 # Log format:
-#   SeverityID, [Date Time mSec #pid] SeverityLabel -- ProgName: message
+#   SeverityID, [DateTime #pid] SeverityLabel -- ProgName: message
 #
 # Log sample:
-#   I, [Wed Mar 03 02:34:24 JST 1999 895701 #19074]  INFO -- Main: info.
+#   I, [1999-03-03T02:34:24.895701 #19074]  INFO -- Main: info.
 #
-# You may change the date and time format in this manner:
+# You may change the date and time format via #datetime_format=.
 #
-#   logger.datetime_format = "%Y-%m-%d %H:%M:%S"
+#   logger.datetime_format = '%Y-%m-%d %H:%M:%S'
 #         # e.g. "2004-01-03 00:54:26"
 #
-# You may change the overall format with Logger#formatter= method.
+# or via the constructor.
 #
-#   logger.formatter = proc { |severity, datetime, progname, msg|
+#   Logger.new(logdev, datetime_format: '%Y-%m-%d %H:%M:%S')
+#
+# Or, you may change the overall format via the #formatter= method.
+#
+#   logger.formatter = proc do |severity, datetime, progname, msg|
 #     "#{datetime}: #{msg}\n"
-#   }
-#         # e.g. "Thu Sep 22 08:51:08 GMT+9:00 2005: hello world"
+#   end
+#   # e.g. "2005-09-22 08:51:08 +0900: hello world"
+#
+# or via the constructor.
+#
+#   Logger.new(logdev, formatter: proc {|severity, datetime, progname, msg|
+#     "#{datetime}: #{msg}\n"
+#   })
 #
-
-
 class Logger
-  VERSION = "1.2.8.1"
-  ProgName = "#{File.basename(__FILE__)}/#{VERSION}"
-
-  class Error < RuntimeError; end
-  class ShiftingError < Error; end # not used after 1.2.7. just for compat.
-
-  # Logging severity.
-  module Severity
-    DEBUG = 0
-    INFO = 1
-    WARN = 2
-    ERROR = 3
-    FATAL = 4
-    UNKNOWN = 5
+  _, name, rev = %w$Id$
+  if name
+    name = name.chomp(",v")
+  else
+    name = File.basename(__FILE__)
   end
+  rev ||= "v#{VERSION}"
+  ProgName = "#{name}/#{rev}"
+
   include Severity
 
   # Logging severity threshold (e.g. <tt>Logger::INFO</tt>).
-  attr_accessor :level
+  attr_reader :level
+
+  # Set logging severity threshold.
+  #
+  # +severity+:: The Severity of the log message.
+  def level=(severity)
+    if severity.is_a?(Integer)
+      @level = severity
+    else
+      case severity.to_s.downcase
+      when 'debug'
+        @level = DEBUG
+      when 'info'
+        @level = INFO
+      when 'warn'
+        @level = WARN
+      when 'error'
+        @level = ERROR
+      when 'fatal'
+        @level = FATAL
+      when 'unknown'
+        @level = UNKNOWN
+      else
+        raise ArgumentError, "invalid log level: #{severity}"
+      end
+    end
+  end
 
-  # Logging program name.
+  # Program name to include in log messages.
   attr_accessor :progname
 
-  # Logging date-time format (string passed to +strftime+).
+  # Set date-time format.
+  #
+  # +datetime_format+:: A string suitable for passing to +strftime+.
   def datetime_format=(datetime_format)
     @default_formatter.datetime_format = datetime_format
   end
 
-  # Returns the date format (string passed to +strftime+) being used (it's set
-  # using datetime_format=)
+  # Returns the date format being used.  See #datetime_format=
   def datetime_format
     @default_formatter.datetime_format
   end
 
-  # Logging formatter.  formatter#call is invoked with 4 arguments; severity,
-  # time, progname and msg for each log.  Bear in mind that time is a Time and
-  # msg is an Object that user passed and it could not be a String.  It is
-  # expected to return a logdev#write-able Object.  Default formatter is used
-  # when no formatter is set.
+  # Logging formatter, as a +Proc+ that will take four arguments and
+  # return the formatted message. The arguments are:
+  #
+  # +severity+:: The Severity of the log message.
+  # +time+:: A Time instance representing when the message was logged.
+  # +progname+:: The #progname configured, or passed to the logger method.
+  # +msg+:: The _Object_ the user passed to the log message; not necessarily a
+  #         String.
+  #
+  # The block should return an Object that can be written to the logging
+  # device via +write+.  The default formatter is used when no formatter is
+  # set.
   attr_accessor :formatter
 
   alias sev_threshold level
@@ -235,60 +304,119 @@ class Logger
 
   # Returns +true+ iff the current severity level allows for the printing of
   # +DEBUG+ messages.
-  def debug?; @level <= DEBUG; end
+  def debug?; level <= DEBUG; end
+
+  # Sets the severity to DEBUG.
+  def debug!; self.level = DEBUG; end
 
   # Returns +true+ iff the current severity level allows for the printing of
   # +INFO+ messages.
-  def info?; @level <= INFO; end
+  def info?; level <= INFO; end
+
+  # Sets the severity to INFO.
+  def info!; self.level = INFO; end
 
   # Returns +true+ iff the current severity level allows for the printing of
   # +WARN+ messages.
-  def warn?; @level <= WARN; end
+  def warn?; level <= WARN; end
+
+  # Sets the severity to WARN.
+  def warn!; self.level = WARN; end
 
   # Returns +true+ iff the current severity level allows for the printing of
   # +ERROR+ messages.
-  def error?; @level <= ERROR; end
+  def error?; level <= ERROR; end
+
+  # Sets the severity to ERROR.
+  def error!; self.level = ERROR; end
 
   # Returns +true+ iff the current severity level allows for the printing of
   # +FATAL+ messages.
-  def fatal?; @level <= FATAL; end
+  def fatal?; level <= FATAL; end
+
+  # Sets the severity to FATAL.
+  def fatal!; self.level = FATAL; end
 
   #
-  # === Synopsis
-  #
-  #   Logger.new(name, shift_age = 7, shift_size = 1048576)
-  #   Logger.new(name, shift_age = 'weekly')
+  # :call-seq:
+  #   Logger.new(logdev, shift_age = 0, shift_size = 1048576)
+  #   Logger.new(logdev, shift_age = 'weekly')
+  #   Logger.new(logdev, level: :info)
+  #   Logger.new(logdev, progname: 'progname')
+  #   Logger.new(logdev, formatter: formatter)
+  #   Logger.new(logdev, datetime_format: '%Y-%m-%d %H:%M:%S')
   #
   # === Args
   #
   # +logdev+::
-  #   The log device.  This is a filename (String) or IO object (typically
-  #   +STDOUT+, +STDERR+, or an open file).
+  #   The log device.  This is a filename (String), IO object (typically
+  #   +STDOUT+, +STDERR+, or an open file), +nil+ (it writes nothing) or
+  #   +File::NULL+ (same as +nil+).
   # +shift_age+::
   #   Number of old log files to keep, *or* frequency of rotation (+daily+,
-  #   +weekly+ or +monthly+).
+  #   +weekly+ or +monthly+). Default value is 0, which disables log file
+  #   rotation.
   # +shift_size+::
-  #   Maximum logfile size (only applies when +shift_age+ is a number).
+  #   Maximum logfile size in bytes (only applies when +shift_age+ is a positive
+  #   Integer). Defaults to +1048576+ (1MB).
+  # +level+::
+  #   Logging severity threshold. Default values is Logger::DEBUG.
+  # +progname+::
+  #   Program name to include in log messages. Default value is nil.
+  # +formatter+::
+  #   Logging formatter. Default values is an instance of Logger::Formatter.
+  # +datetime_format+::
+  #   Date and time format. Default value is '%Y-%m-%d %H:%M:%S'.
+  # +binmode+::
+  #   Use binary mode on the log device. Default value is false.
+  # +shift_period_suffix+::
+  #   The log file suffix format for +daily+, +weekly+ or +monthly+ rotation.
+  #   Default is '%Y%m%d'.
   #
   # === Description
   #
   # Create an instance.
   #
-  def initialize(logdev, shift_age = 0, shift_size = 1048576)
-    @progname = nil
-    @level = DEBUG
+  def initialize(logdev, shift_age = 0, shift_size = 1048576, level: DEBUG,
+                 progname: nil, formatter: nil, datetime_format: nil,
+                 binmode: false, shift_period_suffix: '%Y%m%d')
+    self.level = level
+    self.progname = progname
     @default_formatter = Formatter.new
-    @formatter = nil
+    self.datetime_format = datetime_format
+    self.formatter = formatter
     @logdev = nil
-    if logdev
-      @logdev = LogDevice.new(logdev, :shift_age => shift_age,
-        :shift_size => shift_size)
+    if logdev && logdev != File::NULL
+      @logdev = LogDevice.new(logdev, shift_age: shift_age,
+        shift_size: shift_size,
+        shift_period_suffix: shift_period_suffix,
+        binmode: binmode)
     end
   end
 
   #
-  # === Synopsis
+  # :call-seq:
+  #   Logger#reopen
+  #   Logger#reopen(logdev)
+  #
+  # === Args
+  #
+  # +logdev+::
+  #   The log device.  This is a filename (String) or IO object (typically
+  #   +STDOUT+, +STDERR+, or an open file).  reopen the same filename if
+  #   it is +nil+, do nothing for IO.  Default is +nil+.
+  #
+  # === Description
+  #
+  # Reopen a log device.
+  #
+  def reopen(logdev = nil)
+    @logdev&.reopen(logdev)
+    self
+  end
+
   #
+  # :call-seq:
   #   Logger#add(severity, message = nil, progname = nil) { ... }
   #
   # === Args
@@ -306,10 +434,8 @@ class Logger
   #
   # === Return
   #
-  # +true+ if successful, +false+ otherwise.
-  #
-  # When the given severity is not high enough (for this particular logger), log
-  # no message, and return +true+.
+  # When the given severity is not high enough (for this particular logger),
+  # log no message, and return +true+.
   #
   # === Description
   #
@@ -328,14 +454,16 @@ class Logger
   #
   # * Logfile is not locked.
   # * Append open does not need to lock file.
-  # * But on the OS which supports multi I/O, records possibly be mixed.
+  # * If the OS supports multi I/O, records possibly may be mixed.
   #
-  def add(severity, message = nil, progname = nil, &block)
+  def add(severity, message = nil, progname = nil)
     severity ||= UNKNOWN
-    if @logdev.nil? or severity < @level
+    if @logdev.nil? or severity < level
       return true
     end
-    progname ||= @progname
+    if progname.nil?
+      progname = @progname
+    end
     if message.nil?
       if block_given?
         message = yield
@@ -355,9 +483,7 @@ class Logger
   # device exists, return +nil+.
   #
   def <<(msg)
-    unless @logdev.nil?
-      @logdev.write(msg)
-    end
+    @logdev&.write(msg)
   end
 
   #
@@ -369,12 +495,20 @@ class Logger
     add(DEBUG, nil, progname, &block)
   end
 
+  #
+  # :call-seq:
+  #   info(message)
+  #   info(progname, &block)
   #
   # Log an +INFO+ message.
   #
-  # The message can come either from the +progname+ argument or the +block+.  If
-  # both are provided, then the +block+ is used as the message, and +progname+
-  # is used as the program name.
+  # +message+:: The message to log; does not need to be a String.
+  # +progname+:: In the block form, this is the #progname to use in the
+  #              log message.  The default can be set with #progname=.
+  # +block+:: Evaluates to the message to log.  This is not evaluated unless
+  #           the logger's level is sufficient to log the message.  This
+  #           allows you to create potentially expensive logging messages that
+  #           are only called when the logger is configured to show them.
   #
   # === Examples
   #
@@ -385,7 +519,7 @@ class Logger
   #   logger.info { "User typed #{input}" }
   #
   # You'll probably stick to the second form above, unless you want to provide a
-  # program name (which you can do with <tt>Logger#progname=</tt> as well).
+  # program name (which you can do with #progname= as well).
   #
   # === Return
   #
@@ -423,8 +557,8 @@ class Logger
   end
 
   #
-  # Log an +UNKNOWN+ message.  This will be printed no matter what the logger
-  # level.
+  # Log an +UNKNOWN+ message.  This will be printed no matter what the logger's
+  # level is.
   #
   # See #info for more information.
   #
@@ -436,13 +570,13 @@ class Logger
   # Close the logging device.
   #
   def close
-    @logdev.close if @logdev
+    @logdev&.close
   end
 
 private
 
-  # Severity label for logging. (max 5 char)
-  SEV_LABEL = %w(DEBUG INFO WARN ERROR FATAL ANY)
+  # Severity label for logging (max 5 chars).
+  SEV_LABEL = %w(DEBUG INFO WARN ERROR FATAL ANY).freeze
 
   def format_severity(severity)
     SEV_LABEL[severity] || 'ANY'
@@ -451,309 +585,4 @@ private
   def format_message(severity, datetime, progname, msg)
     (@formatter || @default_formatter).call(severity, datetime, progname, msg)
   end
-
-
-  class Formatter
-    Format = "%s, [%s#%d] %5s -- %s: %s\n"
-
-    attr_accessor :datetime_format
-
-    def initialize
-      @datetime_format = nil
-    end
-
-    def call(severity, time, progname, msg)
-      Format % [severity[0..0], format_datetime(time), $$, severity, progname,
-        msg2str(msg)]
-    end
-
-  private
-
-    def format_datetime(time)
-      if @datetime_format.nil?
-        time.strftime("%Y-%m-%dT%H:%M:%S.") << "%06d " % time.usec
-      else
-        time.strftime(@datetime_format)
-      end
-    end
-
-    def msg2str(msg)
-      case msg
-      when ::String
-        msg
-      when ::Exception
-        "#{ msg.message } (#{ msg.class })\n" <<
-          (msg.backtrace || []).join("\n")
-      else
-        msg.inspect
-      end
-    end
-  end
-
-
-  class LogDevice
-    attr_reader :dev
-    attr_reader :filename
-
-    class LogDeviceMutex
-      include MonitorMixin
-    end
-
-    def initialize(log = nil, opt = {})
-      @dev = @filename = @shift_age = @shift_size = nil
-      @mutex = LogDeviceMutex.new
-      if log.respond_to?(:write) and log.respond_to?(:close)
-        @dev = log
-      else
-        @dev = open_logfile(log)
-        @dev.sync = true
-        @filename = log
-        @shift_age = opt[:shift_age] || 7
-        @shift_size = opt[:shift_size] || 1048576
-      end
-    end
-
-    def write(message)
-      begin
-        @mutex.synchronize do
-          if @shift_age and @dev.respond_to?(:stat)
-            begin
-              check_shift_log
-            rescue
-              warn("log shifting failed. #{$!}")
-            end
-          end
-          begin
-            @dev.write(message)
-          rescue
-            warn("log writing failed. #{$!}")
-          end
-        end
-      rescue Exception => ignored
-        warn("log writing failed. #{ignored}")
-      end
-    end
-
-    def close
-      begin
-        @mutex.synchronize do
-          @dev.close rescue nil
-        end
-      rescue Exception
-        @dev.close rescue nil
-      end
-    end
-
-  private
-
-    def open_logfile(filename)
-      if (FileTest.exist?(filename))
-        open(filename, (File::WRONLY | File::APPEND))
-      else
-        create_logfile(filename)
-      end
-    end
-
-    def create_logfile(filename)
-      logdev = open(filename, (File::WRONLY | File::APPEND | File::CREAT))
-      logdev.sync = true
-      add_log_header(logdev)
-      logdev
-    end
-
-    def add_log_header(file)
-      file.write(
-        "# Logfile created on %s by %s\n" % [Time.now.to_s, Logger::ProgName]
-      )
-    end
-
-    SiD = 24 * 60 * 60
-
-    def check_shift_log
-      if @shift_age.is_a?(Integer)
-        # Note: always returns false if '0'.
-        if @filename && (@shift_age > 0) && (@dev.stat.size > @shift_size)
-          shift_log_age
-        end
-      else
-        now = Time.now
-        period_end = previous_period_end(now)
-        if @dev.stat.mtime <= period_end
-          shift_log_period(period_end)
-        end
-      end
-    end
-
-    def shift_log_age
-      (@shift_age-3).downto(0) do |i|
-        if FileTest.exist?("#{@filename}.#{i}")
-          File.rename("#{@filename}.#{i}", "#{@filename}.#{i+1}")
-        end
-      end
-      @dev.close rescue nil
-      File.rename("#{@filename}", "#{@filename}.0")
-      @dev = create_logfile(@filename)
-      return true
-    end
-
-    def shift_log_period(period_end)
-      postfix = period_end.strftime("%Y%m%d") # YYYYMMDD
-      age_file = "#{@filename}.#{postfix}"
-      if FileTest.exist?(age_file)
-        # try to avoid filename crash caused by Timestamp change.
-        idx = 0
-        # .99 can be overridden; avoid too much file search with 'loop do'
-        while idx < 100
-          idx += 1
-          age_file = "#{@filename}.#{postfix}.#{idx}"
-          break unless FileTest.exist?(age_file)
-        end
-      end
-      @dev.close rescue nil
-      File.rename("#{@filename}", age_file)
-      @dev = create_logfile(@filename)
-      return true
-    end
-
-    def previous_period_end(now)
-      case @shift_age
-      when /^daily$/
-        eod(now - 1 * SiD)
-      when /^weekly$/
-        eod(now - ((now.wday + 1) * SiD))
-      when /^monthly$/
-        eod(now - now.mday * SiD)
-      else
-        now
-      end
-    end
-
-    def eod(t)
-      Time.mktime(t.year, t.month, t.mday, 23, 59, 59)
-    end
-  end
-
-
-  #
-  # == Description
-  #
-  # Application -- Add logging support to your application.
-  #
-  # == Usage
-  #
-  # 1. Define your application class as a sub-class of this class.
-  # 2. Override 'run' method in your class to do many things.
-  # 3. Instantiate it and invoke 'start'.
-  #
-  # == Example
-  #
-  #   class FooApp < Application
-  #     def initialize(foo_app, application_specific, arguments)
-  #       super('FooApp') # Name of the application.
-  #     end
-  #
-  #     def run
-  #       ...
-  #       log(WARN, 'warning', 'my_method1')
-  #       ...
-  #       @log.error('my_method2') { 'Error!' }
-  #       ...
-  #     end
-  #   end
-  #
-  #   status = FooApp.new(....).start
-  #
-  class Application
-    include Logger::Severity
-
-    # Name of the application given at initialize.
-    attr_reader :appname
-
-    #
-    # == Synopsis
-    #
-    #   Application.new(appname = '')
-    #
-    # == Args
-    #
-    # +appname+:: Name of the application.
-    #
-    # == Description
-    #
-    # Create an instance.  Log device is +STDERR+ by default.  This can be
-    # changed with #set_log.
-    #
-    def initialize(appname = nil)
-      @appname = appname
-      @log = Logger.new(STDERR)
-      @log.progname = @appname
-      @level = @log.level
-    end
-
-    #
-    # Start the application.  Return the status code.
-    #
-    def start
-      status = -1
-      begin
-        log(INFO, "Start of #{ @appname }.")
-        status = run
-      rescue
-        log(FATAL, "Detected an exception. Stopping ... #{$!} (#{$!.class})\n" << $@.join("\n"))
-      ensure
-        log(INFO, "End of #{ @appname }. (status: #{ status.to_s })")
-      end
-      status
-    end
-
-    # Logger for this application.  See the class Logger for an explanation.
-    def logger
-      @log
-    end
-
-    #
-    # Sets the logger for this application.  See the class Logger for an explanation.
-    #
-    def logger=(logger)
-      @log = logger
-      @log.progname = @appname
-      @log.level = @level
-    end
-
-    #
-    # Sets the log device for this application.  See <tt>Logger.new</tt> for an explanation
-    # of the arguments.
-    #
-    def set_log(logdev, shift_age = 0, shift_size = 1024000)
-      @log = Logger.new(logdev, shift_age, shift_size)
-      @log.progname = @appname
-      @log.level = @level
-    end
-
-    def log=(logdev)
-      set_log(logdev)
-    end
-
-    #
-    # Set the logging threshold, just like <tt>Logger#level=</tt>.
-    #
-    def level=(level)
-      @level = level
-      @log.level = @level
-    end
-
-    #
-    # See Logger#add.  This application's +appname+ is used.
-    #
-    def log(severity, message = nil, &block)
-      @log.add(severity, message, @appname, &block) if @log
-    end
-
-  private
-
-    def run
-      # TODO: should be an NotImplementedError
-      raise RuntimeError.new('Method run must be defined in the derived class.')
-    end
-  end
 end