logging 2.0.0 → 2.3.0

data/lib/logging/appenders/console.rb

@@ -1,81 +1,92 @@
-
 module Logging::Appenders
 
-  # Accessor / Factory for the Stdout appender.
-  #
-  def self.stdout( *args )
-    if args.empty?
-      return self['stdout'] || ::Logging::Appenders::Stdout.new
-    end
-    ::Logging::Appenders::Stdout.new(*args)
-  end
-
-  # This class provides an Appender that can write to STDOUT.
-  #
-  class Stdout < ::Logging::Appenders::IO
+  # This class is provides an Appender base class for writing to the standard IO
+  # stream - STDOUT and STDERR. This class should not be instantiated directly.
+  # The `Stdout` and `Stderr` subclasses should be used.
+  class Console < ::Logging::Appenders::IO
 
     # call-seq:
     #    Stdout.new( name = 'stdout' )
-    #    Stdout.new( :layout => layout )
+    #    Stderr.new( :layout => layout )
     #    Stdout.new( name = 'stdout', :level => 'info' )
     #
-    # Creates a new Stdout Appender. The name 'stdout' will be used unless
-    # another is given. Optionally, a layout can be given for the appender
-    # to use (otherwise a basic appender will be created) and a log level
-    # can be specified.
+    # Creates a new Stdout/Stderr Appender. The name 'stdout'/'stderr' will be
+    # used unless another is given. Optionally, a layout can be given for the
+    # appender to use (otherwise a basic appender will be created) and a log
+    # level can be specified.
     #
     # Options:
     #
-    #    :layout   => the layout to use when formatting log events
-    #    :level    => the level at which to log
+    #    :layout => the layout to use when formatting log events
+    #    :level  => the level at which to log
     #
     def initialize( *args )
-      opts = Hash === args.last ? args.pop : {}
-      name = args.empty? ? 'stdout' : args.shift
+      name = self.class.name.split("::").last.downcase
+
+      opts = args.last.is_a?(Hash) ? args.pop : {}
+      name = args.shift unless args.empty?
 
-      opts[:encoding] = STDOUT.external_encoding if STDOUT.respond_to? :external_encoding
+      io = open_fd
+      opts[:encoding] = io.external_encoding
 
-      super(name, STDOUT, opts)
+      super(name, io, opts)
     end
-  end  # Stdout
 
+    # Reopen the connection to the underlying logging destination. If the
+    # connection is currently closed then it will be opened. If the connection
+    # is currently open then it will be closed and immediately reopened.
+    def reopen
+      @mutex.synchronize {
+        if defined? @io && @io
+          flush
+          @io.close rescue nil
+        end
+        @io = open_fd
+      }
+      super
+      self
+    end
 
-  # Accessor / Factory for the Stderr appender.
-  #
-  def self.stderr( *args )
-    if args.empty?
-      return self['stderr'] || ::Logging::Appenders::Stderr.new
+  private
+
+    def open_fd
+      case self.class.name
+      when "Logging::Appenders::Stdout"
+        fd = STDOUT.fileno
+        encoding = STDOUT.external_encoding
+      when "Logging::Appenders::Stderr"
+        fd = STDERR.fileno
+        encoding = STDERR.external_encoding
+      else
+        raise RuntimeError, "Please do not use the `Logging::Appenders::Console` class directly - " +
+                            "use `Logging::Appenders::Stdout` and `Logging::Appenders::Stderr` instead" +
+                            " [class #{self.class.name}]"
+      end
+
+      mode = ::File::WRONLY | ::File::APPEND
+      ::IO.for_fd(fd, mode: mode, encoding: encoding)
     end
-    ::Logging::Appenders::Stderr.new(*args)
   end
 
-  # This class provides an Appender that can write to STDERR.
-  #
-  class Stderr < ::Logging::Appenders::IO
-
-    # call-seq:
-    #    Stderr.new( name = 'stderr' )
-    #    Stderr.new( :layout => layout )
-    #    Stderr.new( name = 'stderr', :level => 'warn' )
-    #
-    # Creates a new Stderr Appender. The name 'stderr' will be used unless
-    # another is given. Optionally, a layout can be given for the appender
-    # to use (otherwise a basic appender will be created) and a log level
-    # can be specified.
-    #
-    # Options:
-    #
-    #    :layout   => the layout to use when formatting log events
-    #    :level    => the level at which to log
-    #
-    def initialize( *args )
-      opts = Hash === args.last ? args.pop : {}
-      name = args.empty? ? 'stderr' : args.shift
+  # This class provides an Appender that can write to STDOUT.
+  Stdout = Class.new(Console)
 
-      opts[:encoding] = STDERR.external_encoding if STDERR.respond_to? :external_encoding
+  # This class provides an Appender that can write to STDERR.
+  Stderr = Class.new(Console)
 
-      super(name, STDERR, opts)
+  # Accessor / Factory for the Stdout appender.
+  def self.stdout( *args )
+    if args.empty?
+      return self['stdout'] || ::Logging::Appenders::Stdout.new
     end
-  end  # Stderr
-end  # Logging::Appenders
+    ::Logging::Appenders::Stdout.new(*args)
+  end
 
+  # Accessor / Factory for the Stderr appender.
+  def self.stderr( *args )
+    if args.empty?
+      return self['stderr'] || ::Logging::Appenders::Stderr.new
+    end
+    ::Logging::Appenders::Stderr.new(*args)
+  end
+end

data/lib/logging/appenders/file.rb

@@ -2,14 +2,12 @@
 module Logging::Appenders
 
   # Accessor / Factory for the File appender.
-  #
   def self.file( *args )
-    return ::Logging::Appenders::File if args.empty?
+    fail ArgumentError, '::Logging::Appenders::File needs a name as first argument.' if args.empty?
     ::Logging::Appenders::File.new(*args)
   end
 
   # This class provides an Appender that can write to a File.
-  #
   class File < ::Logging::Appenders::IO
 
     # call-seq:
@@ -21,15 +19,14 @@ module Logging::Appenders
     # writable.
     #
     # An +ArgumentError+ is raised if any of these assertions fail.
-    #
     def self.assert_valid_logfile( fn )
       if ::File.exist?(fn)
-        if not ::File.file?(fn)
+        if !::File.file?(fn)
           raise ArgumentError, "#{fn} is not a regular file"
-        elsif not ::File.writable?(fn)
+        elsif !::File.writable?(fn)
           raise ArgumentError, "#{fn} is not writeable"
         end
-      elsif not ::File.writable?(::File.dirname(fn))
+      elsif !::File.writable?(::File.dirname(fn))
         raise ArgumentError, "#{::File.dirname(fn)} is not writable"
       end
       true
@@ -45,41 +42,65 @@ module Logging::Appenders
     # created. If the :truncate option is set to +true+ then the file will
     # be truncated before writing begins; otherwise, log messages will be
     # appended to the file.
-    #
     def initialize( name, opts = {} )
-      @fn = opts.fetch(:filename, name)
-      raise ArgumentError, 'no filename was given' if @fn.nil?
+      @filename = opts.fetch(:filename, name)
+      raise ArgumentError, 'no filename was given' if @filename.nil?
 
-      @fn = ::File.expand_path(@fn)
-      self.class.assert_valid_logfile(@fn)
-      @mode = opts.fetch(:truncate, false) ? 'w' : 'a'
+      @filename = ::File.expand_path(@filename).freeze
+      self.class.assert_valid_logfile(@filename)
 
       self.encoding = opts.fetch(:encoding, self.encoding)
-      @mode = "#{@mode}:#{self.encoding}" if self.encoding
 
-      super(name, ::File.new(@fn, @mode), opts)
+      io = open_file
+      super(name, io, opts)
+
+      truncate if opts.fetch(:truncate, false)
     end
 
     # Returns the path to the logfile.
-    #
-    def filename() @fn.dup end
+    attr_reader :filename
 
     # Reopen the connection to the underlying logging destination. If the
     # connection is currently closed then it will be opened. If the connection
     # is currently open then it will be closed and immediately opened.
-    #
     def reopen
       @mutex.synchronize {
-        if defined? @io and @io
+        if defined? @io && @io
           flush
           @io.close rescue nil
         end
-        @io = ::File.new(@fn, @mode)
+        @io = open_file
       }
       super
       self
     end
 
-  end  # FileAppender
-end  # Logging::Appenders
 
+  protected
+
+    def truncate
+      @mutex.synchronize {
+        begin
+          @io.flock(::File::LOCK_EX)
+          @io.truncate(0)
+        ensure
+          @io.flock(::File::LOCK_UN)
+        end
+      }
+    end
+
+    def open_file
+      mode = ::File::WRONLY | ::File::APPEND
+      ::File.open(filename, mode: mode, external_encoding: encoding)
+    rescue Errno::ENOENT
+      create_file
+    end
+
+    def create_file
+      mode = ::File::WRONLY | ::File::APPEND | ::File::CREAT | ::File::EXCL
+      ::File.open(filename, mode: mode, external_encoding: encoding)
+    rescue Errno::EEXIST
+      open_file
+    end
+  end
+end

data/lib/logging/appenders/io.rb

@@ -2,7 +2,6 @@
 module Logging::Appenders
 
   # Accessor / Factory for the IO appender.
-  #
   def self.io( *args )
     return ::Logging::Appenders::IO if args.empty?
     ::Logging::Appenders::IO.new(*args)
@@ -10,14 +9,12 @@ module Logging::Appenders
 
   # This class provides an Appender that can write to any IO stream
   # configured for writing.
-  #
   class IO < ::Logging::Appender
     include Buffering
 
     # The method that will be used to close the IO stream. Defaults to :close
     # but can be :close_read, :close_write or nil. When nil, the IO stream
     # will not be closed when the appender's close method is called.
-    #
     attr_accessor :close_method
 
     # call-seq:
@@ -26,15 +23,13 @@ module Logging::Appenders
     #
     # Creates a new IO Appender using the given name that will use the _io_
     # stream as the logging destination.
-    #
     def initialize( name, io, opts = {} )
-      unless io.respond_to? :syswrite
+      unless io.respond_to? :write
         raise TypeError, "expecting an IO object but got '#{io.class.name}'"
       end
 
       @io = io
-      @io.sync = true if io.respond_to? :sync=    # syswrite complains if the IO stream is buffered
-      @io.flush rescue nil                        # syswrite also complains if in unbuffered mode and buffer isn't empty
+      @io.sync = true if io.respond_to? :sync=
       @close_method = :close
 
       super(name, opts)
@@ -48,37 +43,48 @@ module Logging::Appenders
     # destination if the _footer_ flag is set to +true+. Log events will
     # no longer be written to the logging destination after the appender
     # is closed.
-    #
     def close( *args )
       return self if @io.nil?
       super
 
       io, @io = @io, nil
       unless [STDIN, STDERR, STDOUT].include?(io)
-        io.send(@close_method) if @close_method and io.respond_to? @close_method
+        io.send(@close_method) if @close_method && io.respond_to?(@close_method)
       end
     rescue IOError
     ensure
       return self
     end
 
+    # Reopen the connection to the underlying logging destination. If the
+    # connection is currently closed then it will be opened. If the connection
+    # is currently open then it will be closed and immediately opened. If
+    # supported, the IO will have its sync mode set to `true` so that all writes
+    # are immediately flushed to the underlying operating system.
+    def reopen
+      super
+      @io.sync = true if @io.respond_to? :sync=
+      self
+    end
 
   private
 
     # This method is called by the buffering code when messages need to be
     # written to the logging destination.
-    #
     def canonical_write( str )
       return self if @io.nil?
-      str = str.force_encoding(encoding) if encoding and str.encoding != encoding
-      @io.syswrite str
+      str = str.force_encoding(encoding) if encoding && str.encoding != encoding
+      @mutex.synchronize { @io.write str }
       self
     rescue StandardError => err
+      handle_internal_error(err)
+    end
+
+    def handle_internal_error( err )
+      return err if off?
       self.level = :off
       ::Logging.log_internal {"appender #{name.inspect} has been disabled"}
       ::Logging.log_internal_error(err)
     end
-
-  end  # IO
-end  # Logging::Appenders
-
+  end
+end

data/lib/logging/appenders/rolling_file.rb

@@ -2,7 +2,7 @@ module Logging::Appenders
 
   # Accessor / Factory for the RollingFile appender.
   def self.rolling_file( *args )
-    return ::Logging::Appenders::RollingFile if args.empty?
+    fail ArgumentError, '::Logging::Appenders::RollingFile needs a name as first argument.' if args.empty?
     ::Logging::Appenders::RollingFile.new(*args)
   end
 
@@ -84,24 +84,32 @@ module Logging::Appenders
     #               'date'.
     #
     def initialize( name, opts = {} )
-      @roller = Roller.new name, opts
+      @roller = Roller.new(
+        opts.fetch(:filename, name),
+        age:     opts.fetch(:age, nil),
+        size:    opts.fetch(:size, nil),
+        roll_by: opts.fetch(:roll_by, nil),
+        keep:    opts.fetch(:keep, nil)
+      )
 
       # grab our options
       @size = opts.fetch(:size, nil)
       @size = Integer(@size) unless @size.nil?
 
-      @age_fn = filename + '.age'
+      @age_fn = self.filename + '.age'
       @age_fn_mtime = nil
       @age = opts.fetch(:age, nil)
 
       # create our `sufficiently_aged?` method
       build_singleton_methods
-      FileUtils.touch(@age_fn) if @age && !test(?f, @age_fn)
+      FileUtils.touch(@age_fn) if @age && !::File.file?(@age_fn)
 
       # we are opening the file in read/write mode so that a shared lock can
       # be used on the file descriptor => http://pubs.opengroup.org/onlinepubs/009695399/functions/fcntl.html
-      @mode = encoding ? "a+:#{encoding}" : 'a+'
-      super(name, ::File.new(filename, @mode), opts)
+      self.encoding = opts.fetch(:encoding, self.encoding)
+
+      io = open_file
+      super(name, io, opts)
 
       # if the truncate flag was set to true, then roll
       roll_now = opts.fetch(:truncate, false)
@@ -121,11 +129,11 @@ module Logging::Appenders
     # is currently open then it will be closed and immediately opened.
     def reopen
       @mutex.synchronize {
-        if defined?(@io) && @io
+        if defined? @io && @io
           flush
           @io.close rescue nil
         end
-        @io = ::File.new(filename, @mode)
+        @io = open_file
       }
       super
       self
@@ -134,6 +142,20 @@ module Logging::Appenders
 
   private
 
+    def open_file
+      mode = ::File::RDWR | ::File::APPEND
+      ::File.open(filename, mode: mode, external_encoding: encoding)
+    rescue Errno::ENOENT
+      create_file
+    end
+
+    def create_file
+      mode = ::File::RDWR | ::File::APPEND | ::File::CREAT | ::File::EXCL
+      ::File.open(filename, mode: mode, external_encoding: encoding)
+    rescue Errno::EEXIST
+      open_file
+    end
+
     # Returns the file name to use as the temporary copy location. We are
     # using copy-and-truncate semantics for rolling files so that the IO
     # file descriptor remains valid during rolling.
@@ -141,6 +163,15 @@ module Logging::Appenders
       @roller.copy_file
     end
 
+    # Returns the modification time of the copy file if one exists. Otherwise
+    # returns `nil`.
+    def copy_file_mtime
+      return nil unless ::File.exist?(copy_file)
+      ::File.mtime(copy_file)
+    rescue Errno::ENOENT
+      nil
+    end
+
     # Write the given _event_ to the log file. The log file will be rolled
     # if the maximum file size is exceeded or if the file is older than the
     # maximum age.
@@ -148,14 +179,18 @@ module Logging::Appenders
       return self if @io.nil?
 
       str = str.force_encoding(encoding) if encoding && str.encoding != encoding
-      @io.flock_sh { @io.syswrite str }
+      @mutex.synchronize {
+        @io.flock_sh { @io.write str }
+      }
 
       if roll_required?
-        @io.flock? {
-          @age_fn_mtime = nil
-          copy_truncate if roll_required?
+        @mutex.synchronize {
+          @io.flock? {
+            @age_fn_mtime = nil
+            copy_truncate if roll_required?
+          }
+          @roller.roll_files
         }
-        @roller.roll_files
       end
       self
     rescue StandardError => err
@@ -166,7 +201,8 @@ module Logging::Appenders
 
     # Returns +true+ if the log file needs to be rolled.
     def roll_required?
-      return false if ::File.exist?(copy_file) && (Time.now - ::File.mtime(copy_file)) < 180
+      mtime = copy_file_mtime
+      return false if mtime && (Time.now - mtime) < 180
 
       # check if max size has been exceeded
       s = @size ? ::File.size(filename) > @size : false
@@ -183,7 +219,7 @@ module Logging::Appenders
     def copy_truncate
       return unless ::File.exist?(filename)
       FileUtils.concat filename, copy_file
-      @io.truncate 0
+      @io.truncate(0)
 
       # touch the age file if needed
       if @age
@@ -245,22 +281,22 @@ module Logging::Appenders
       # Create a new roller. See the RollingFile#initialize documentation for
       # the list of options.
       #
-      # name - The appender name as a String
-      # opts - The options Hash
+      # filename - the name of the file to roll
+      # age      - the age of the file at which it should be rolled
+      # size     - the size of the file in bytes at which it should be rolled
+      # roll_by  - roll either by 'number' or 'date'
+      # keep     - the number of log files to keep when rolling
       #
-      def initialize( name, opts )
+      def initialize( filename, age: nil, size: nil, roll_by: nil, keep: nil )
         # raise an error if a filename was not given
-        @fn = opts.fetch(:filename, name)
+        @fn = filename
         raise ArgumentError, 'no filename was given' if @fn.nil?
 
         if (m = RGXP.match @fn)
           @roll_by = ("#{m[2]}%d" == m[1]) ? :number : :date
         else
-          age = opts.fetch(:age, nil)
-          size = opts.fetch(:size, nil)
-
           @roll_by =
-              case opts.fetch(:roll_by, nil)
+              case roll_by
               when 'number'; :number
               when 'date'; :date
               else
@@ -283,8 +319,7 @@ module Logging::Appenders
         ::Logging::Appenders::File.assert_valid_logfile(filename)
 
         @roll = false
-        @keep = opts.fetch(:keep, nil)
-        @keep = Integer(keep) unless keep.nil?
+        @keep = keep.nil? ? nil : Integer(keep)
       end
 
       attr_reader :keep, :roll_by
@@ -337,7 +372,6 @@ module Logging::Appenders
         files.delete copy_file
 
         self.send "roll_by_#{roll_by}", files
-
         nil
       ensure
         self.roll = false