logger 1.2.8.1 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fca3ed305eb759ed28a0ea917d653feee81fc4d399a53a44e6649d8e8389defb
-  data.tar.gz: 90cef9d07cb58cb5049c1a869ae56ec609e0dfd1befcac6053b97602e11ee609
+  metadata.gz: 6b7218297d498d773ba9c79d57749a01f259d336a4e9b5acbfe51274d2442500
+  data.tar.gz: c455593961790cfaf065b7b6b7798d9c184900e1ccdd0aa4f89411e33400e4b0
 SHA512:
-  metadata.gz: c2c96afb68a6e3a22e53673119f673bd6490d6d1c5c184da06677633648c0e86ce6c7eaacbb4dca55c4d3c800ea8d7708c55235a854987c98ed3f20feee185f9
-  data.tar.gz: c5e39c441722c99cd6fee091939303d22448a329543699b1deac011d3500f3cf939987ff6c4c64db1cff526a746e1e6050f9af801f057f3aca5181ea734599fa
+  metadata.gz: 5db2250788d1a9c583685501312a5f6ef277b3148b164b5ed1c2b123a88560ff795b40eee1ac70cf5f466e3dbd771e3d93773c387599b7f7c9916dd7319a99a6
+  data.tar.gz: 94a96a2fba4c2e56e18e2e40f4ca0d0238edd355f65b95182e9ffdfb9a380bd7f932cf9734c0baa2a4c7b79df182cf27151972bfdd3efc6829f58530cd28c287

data/.gitignore

@@ -0,0 +1,8 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.travis.yml

@@ -0,0 +1,6 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.5.1
+  - ruby-head  
+before_install: gem install bundler -v 1.16.2

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in logger.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (C) 1993-2013 Yukihiro Matsumoto. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+1. Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGE.

data/README.md

@@ -0,0 +1,39 @@
+# Logger
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/logger`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'logger'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install logger
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/ruby/logger.
+
+## License
+
+The gem is available as open source under the terms of the [BSD-2-Clause](LICENSE.txt).

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib" << "test/lib"
+  t.test_files = FileList["test/**/test_*.rb"]
+end
+
+task :default => :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "logger"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/logger.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: false
 # logger.rb - simple logging utility
 # Copyright (C) 2000-2003, 2005, 2008, 2011  NAKAMURA, Hiroshi <nahi@ruby-lang.org>.
 #
@@ -7,47 +8,42 @@
 #   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'
 
-
 # == 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 +53,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+:
+#
+#   require 'logger'
 #
-#   log = Logger.new(STDOUT)
-#   log.level = Logger::WARN
+#   logger = Logger.new(STDOUT)
+#   logger.level = Logger::WARN
 #
-#   log.debug("Created logger")
-#   log.info("Program started")
-#   log.warn("Nothing to do!")
+#   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 +109,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 +127,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 +147,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 +175,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 +196,123 @@ 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}"
+  VERSION = "1.3.0"
+  _, name, rev = %w$Id$
+  if name
+    name = name.chomp(",v")
+  else
+    name = File.basename(__FILE__)
+  end
+  rev ||= "v#{VERSION}"
+  ProgName = "#{name}/#{rev}".freeze
 
-  class Error < RuntimeError; end
-  class ShiftingError < Error; end # not used after 1.2.7. just for compat.
+  class Error < RuntimeError # :nodoc:
+  end
+  # not used after 1.2.7. just for compat.
+  class ShiftingError < Error # :nodoc:
+  end
 
   # Logging severity.
   module Severity
+    # Low-level information, mostly for developers.
     DEBUG = 0
+    # Generic (useful) information about system operation.
     INFO = 1
+    # A warning.
     WARN = 2
+    # A handleable error condition.
     ERROR = 3
+    # An unhandleable error that results in a program crash.
     FATAL = 4
+    # An unknown message that should always be logged.
     UNKNOWN = 5
   end
   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
@@ -254,10 +339,13 @@ class Logger
   def fatal?; @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
   #
@@ -266,29 +354,65 @@ class Logger
   #   +STDOUT+, +STDERR+, or an open file).
   # +shift_age+::
   #   Number of old log files to keep, *or* frequency of rotation (+daily+,
-  #   +weekly+ or +monthly+).
+  #   +weekly+ or +monthly+). Default value is 0.
   # +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 number).
+  #   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'.
+  # +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,
+                 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)
+        :shift_size => shift_size,
+        :shift_period_suffix => shift_period_suffix)
     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 +430,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 +450,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
       return true
     end
-    progname ||= @progname
+    if progname.nil?
+      progname = @progname
+    end
     if message.nil?
       if block_given?
         message = yield
@@ -355,9 +479,7 @@ class Logger
   # device exists, return +nil+.
   #
   def <<(msg)
-    unless @logdev.nil?
-      @logdev.write(msg)
-    end
+    @logdev&.write(msg)
   end
 
   #
@@ -369,12 +491,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 +515,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 +553,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 +566,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).each(&:freeze).freeze
 
   def format_severity(severity)
     SEV_LABEL[severity] || 'ANY'
@@ -453,8 +583,9 @@ private
   end
 
 
+  # Default formatter for log messages.
   class Formatter
-    Format = "%s, [%s#%d] %5s -- %s: %s\n"
+    Format = "%s, [%s#%d] %5s -- %s: %s\n".freeze
 
     attr_accessor :datetime_format
 
@@ -470,11 +601,7 @@ private
   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
+      time.strftime(@datetime_format || "%Y-%m-%dT%H:%M:%S.%6N ".freeze)
     end
 
     def msg2str(msg)
@@ -490,32 +617,73 @@ private
     end
   end
 
+  module Period
+    module_function
 
-  class LogDevice
-    attr_reader :dev
-    attr_reader :filename
+    SiD = 24 * 60 * 60
 
-    class LogDeviceMutex
-      include MonitorMixin
+    def next_rotate_time(now, shift_age)
+      case shift_age
+      when 'daily'
+        t = Time.mktime(now.year, now.month, now.mday) + SiD
+      when 'weekly'
+        t = Time.mktime(now.year, now.month, now.mday) + SiD * (7 - now.wday)
+      when 'monthly'
+        t = Time.mktime(now.year, now.month, 1) + SiD * 32
+        return Time.mktime(t.year, t.month, 1)
+      else
+        return now
+      end
+      if t.hour.nonzero? or t.min.nonzero? or t.sec.nonzero?
+        hour = t.hour
+        t = Time.mktime(t.year, t.month, t.mday)
+        t += SiD if hour > 12
+      end
+      t
     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
+    def previous_period_end(now, shift_age)
+      case shift_age
+      when 'daily'
+        t = Time.mktime(now.year, now.month, now.mday) - SiD / 2
+      when 'weekly'
+        t = Time.mktime(now.year, now.month, now.mday) - (SiD * now.wday + SiD / 2)
+      when 'monthly'
+        t = Time.mktime(now.year, now.month, 1) - SiD / 2
       else
-        @dev = open_logfile(log)
-        @dev.sync = true
-        @filename = log
-        @shift_age = opt[:shift_age] || 7
-        @shift_size = opt[:shift_size] || 1048576
+        return now
+      end
+      Time.mktime(t.year, t.month, t.mday, 23, 59, 59)
+    end
+  end
+
+  # Device used for logging messages.
+  class LogDevice
+    include Period
+
+    attr_reader :dev
+    attr_reader :filename
+    include MonitorMixin
+
+    def initialize(log = nil, shift_age: nil, shift_size: nil, shift_period_suffix: nil)
+      @dev = @filename = @shift_age = @shift_size = @shift_period_suffix = nil
+      mon_initialize
+      set_dev(log)
+      if @filename
+        @shift_age = shift_age || 7
+        @shift_size = shift_size || 1048576
+        @shift_period_suffix = shift_period_suffix || '%Y%m%d'
+
+        unless @shift_age.is_a?(Integer)
+          base_time = @dev.respond_to?(:stat) ? @dev.stat.mtime : Time.now
+          @next_rotate_time = next_rotate_time(base_time, @shift_age)
+        end
       end
     end
 
     def write(message)
       begin
-        @mutex.synchronize do
+        synchronize do
           if @shift_age and @dev.respond_to?(:stat)
             begin
               check_shift_log
@@ -536,7 +704,7 @@ private
 
     def close
       begin
-        @mutex.synchronize do
+        synchronize do
           @dev.close rescue nil
         end
       rescue Exception
@@ -544,43 +712,110 @@ private
       end
     end
 
+    def reopen(log = nil)
+      # reopen the same filename if no argument, do nothing for IO
+      log ||= @filename if @filename
+      if log
+        synchronize do
+          if @filename and @dev
+            @dev.close rescue nil # close only file opened by Logger
+            @filename = nil
+          end
+          set_dev(log)
+        end
+      end
+      self
+    end
+
   private
 
-    def open_logfile(filename)
-      if (FileTest.exist?(filename))
-        open(filename, (File::WRONLY | File::APPEND))
+    def set_dev(log)
+      if log.respond_to?(:write) and log.respond_to?(:close)
+        @dev = log
       else
+        @dev = open_logfile(log)
+        @dev.sync = true
+        @filename = log
+      end
+    end
+
+    def open_logfile(filename)
+      begin
+        File.open(filename, (File::WRONLY | File::APPEND))
+      rescue Errno::ENOENT
         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)
+      begin
+        logdev = File.open(filename, (File::WRONLY | File::APPEND | File::CREAT | File::EXCL))
+        logdev.flock(File::LOCK_EX)
+        logdev.sync = true
+        add_log_header(logdev)
+        logdev.flock(File::LOCK_UN)
+      rescue Errno::EEXIST
+        # file is created by another process
+        logdev = open_logfile(filename)
+        logdev.sync = true
+      end
       logdev
     end
 
     def add_log_header(file)
       file.write(
         "# Logfile created on %s by %s\n" % [Time.now.to_s, Logger::ProgName]
-      )
+      ) if file.size == 0
     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
+          lock_shift_log { 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)
+        if now >= @next_rotate_time
+          @next_rotate_time = next_rotate_time(now, @shift_age)
+          lock_shift_log { shift_log_period(previous_period_end(now, @shift_age)) }
+        end
+      end
+    end
+
+    if /mswin|mingw/ =~ RUBY_PLATFORM
+      def lock_shift_log
+        yield
+      end
+    else
+      def lock_shift_log
+        retry_limit = 8
+        retry_sleep = 0.1
+        begin
+          File.open(@filename, File::WRONLY | File::APPEND) do |lock|
+            lock.flock(File::LOCK_EX) # inter-process locking. will be unlocked at closing file
+            if File.identical?(@filename, lock) and File.identical?(lock, @dev)
+              yield # log shifting
+            else
+              # log shifted by another process (i-node before locking and i-node after locking are different)
+              @dev.close rescue nil
+              @dev = open_logfile(@filename)
+              @dev.sync = true
+            end
+          end
+        rescue Errno::ENOENT
+          # @filename file would not exist right after #rename and before #create_logfile
+          if retry_limit <= 0
+            warn("log rotation inter-process lock failed. #{$!}")
+          else
+            sleep retry_sleep
+            retry_limit -= 1
+            retry_sleep *= 2
+            retry
+          end
         end
+      rescue
+        warn("log rotation inter-process lock failed. #{$!}")
       end
     end
 
@@ -597,15 +832,15 @@ private
     end
 
     def shift_log_period(period_end)
-      postfix = period_end.strftime("%Y%m%d") # YYYYMMDD
-      age_file = "#{@filename}.#{postfix}"
+      suffix = period_end.strftime(@shift_period_suffix)
+      age_file = "#{@filename}.#{suffix}"
       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}"
+          age_file = "#{@filename}.#{suffix}.#{idx}"
           break unless FileTest.exist?(age_file)
         end
       end
@@ -614,146 +849,5 @@ private
       @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