logging 2.2.2 → 2.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: bb433e2db44c13bc4956095561ad2ad34cd4fabf
-  data.tar.gz: 6d6a401267834a2b1dad3c5992bb4c4c28ea05a0
+SHA256:
+  metadata.gz: 1ec479cf977c621a6b42426cfe7c478a97e106c23762f3608ee67fcbaa49b324
+  data.tar.gz: 6a0c0107cf3c1a1f7504e19e85a9505ad94c4a84991d01eb6c65191257a01163
 SHA512:
-  metadata.gz: 44ad1070f56d8618f9e6c118876364f70442723424d055716928e422a6699a40e744c68a86619227ed8fd5eea26e6c1fd6850f50877c74769a5160d6133b5140
-  data.tar.gz: bf24fb750a15937f18d75b2acc738e323a8ea718661bb9877ea64b0d23eea12def864c3175e71cd1f9b7ccff69c44d661455ff3526e5c192cc0f67c026a77a7f
+  metadata.gz: 2cd72dabcd8b878b73f69ec8a445678b14635ca1c115576ef148a7160673f83939d7706e5d673c32ed11ef2c48046cc7a50bd2c2c0795b2fa79c35e9d4bccf87
+  data.tar.gz: 23422872b58d1bd0e0a146f64e4bb792ef5208da309b16e7650d5c74ca9969b12e6e65dd5ef79a90ce39e0d6c51dbc7514f7a2e913ec74b2e8404a06aefa8975

data/.gitignore

@@ -12,3 +12,4 @@ tmp/
 vendor/
 .rbx
 .rvmrc
+.tool-versions

data/.travis.yml

@@ -9,6 +9,8 @@ rvm:
   - 2.0.0-p648
   - 2.1.10
   - 2.2.7
-  - 2.3.4
-  - 2.4.1
-  - jruby-9.1.8.0
+  - 2.3.8
+  - 2.4.9
+  - 2.5.7
+  - 2.6.5
+  - jruby-9.2.9.0

data/History.txt

@@ -1,3 +1,18 @@
+== 2.3.0 / 2020-07-04
+
+Enhancements
+- all appender output is now synchronized [PR #219]
+- renamed the `LogEvent#method` to no longer conflict with `Kernel#method` [PR #218]
+- @bhuga (not the Fortnite star) added a `raise_errors` method for debugging [PR #203]
+- thanks to @olleolleolle for keeping on top of Travis and Ruby versions
+
+Bug Fixes
+- conosle appenders can be reopened [PR #220]
+- fixed a race condition in the rolling file appender [PR #216]
+- fixed a race condition when opening log file destinations [PR #208 #217]
+- @MikaelSmith fixed a race condition in Logger creation [PR #201]
+- documentation bug fixes [PR #184 #185 #188 #194 #209]
+
 == 2.2.2 / 2017-04-11
 
 Enhancements

data/Rakefile

@@ -26,9 +26,9 @@ Bones {
   use_gmail
 
   depend_on 'little-plugger', '~> 1.1'
-  depend_on 'multi_json',     '~> 1.10'
+  depend_on 'multi_json',     '~> 1.14'
 
-  depend_on 'test-unit', '~> 3.1', :development => true
+  depend_on 'test-unit', '~> 3.3', :development => true
   depend_on 'bones-git', '~> 1.3', :development => true
   #depend_on 'bones-rcov',   :development => true
 }

data/examples/appenders.rb

@@ -1,7 +1,7 @@
 # :stopdoc:
 #
 # Appenders are used to output log events to some logging destination. The
-# same log event can be sent to multiple desitnations by associating
+# same log event can be sent to multiple destinations by associating
 # multiple appenders with the logger.
 #
 # The following is a list of all the available appenders and a brief

data/examples/mdc.rb

@@ -29,9 +29,9 @@
   Logging.mdc['first'] = 'John'
   Logging.mdc['last']  = 'Doe'
 
-  # in this first thread we will log some quotes by Allan Rickman
+  # in this first thread we will log some quotes by Alan Rickman
   t1 = Thread.new {
-    Logging.mdc['first'] = 'Allan'
+    Logging.mdc['first'] = 'Alan'
     Logging.mdc['last']  = 'Rickman'
 
     [ %q{I've never been able to plan my life. I just lurch from indecision to indecision.},

data/lib/logging.rb

@@ -258,6 +258,7 @@ module Logging
       module_eval "MAX_LEVEL_LENGTH = #{longest.length}", __FILE__, __LINE__
 
       self.cause_depth = nil unless defined? @cause_depth
+      self.raise_errors = false unless defined? @raise_errors
 
       initialize_plugins
       levels.keys
@@ -268,8 +269,8 @@ module Logging
     #
     # Defines the default _obj_format_ method to use when converting objects
     # into string representations for logging. _obj_format_ can be one of
-    # <tt>:string</tt>, <tt>:inspect</tt>, or <tt>:yaml</tt>. These
-    # formatting commands map to the following object methods
+    # <tt>:string</tt>, <tt>:inspect</tt>, <tt>:json</tt> or <tt>:yaml</tt>.
+    # These formatting commands map to the following object methods
     #
     # * :string  => to_s
     # * :inspect => inspect
@@ -277,7 +278,7 @@ module Logging
     # * :json    => MultiJson.encode(obj)
     #
     # An +ArgumentError+ is raised if anything other than +:string+,
-    # +:inspect+, +:yaml+ is passed to this method.
+    # +:inspect+, +:json+ or +:yaml+ is passed to this method.
     #
     def format_as( f )
       f = f.intern if f.instance_of? String
@@ -490,6 +491,21 @@ module Logging
       io
     end
 
+    # Raise an exception when an error is encountered while logging, be it with
+    # a backing store, formatter, or anything else. You probably wouldn't want
+    # to enable this outside of test.
+    #
+    # Not that only one error will ever be raised per logging backend, as
+    # backends that raise errors on write will be set to :off.
+    def raise_errors=(boolean)
+      @raise_errors = boolean
+    end
+
+    # Whether or not we should raise errors when writing logs.
+    def raise_errors?
+      @raise_errors
+    end
+
     # :stopdoc:
     # Convert the given level into a canonical form - a lowercase string.
     def levelify( level )
@@ -518,7 +534,7 @@ module Logging
     # exception will be raised again.
     def log_internal_error( err )
       log_internal(-2) { err }
-      raise err if Thread.abort_on_exception
+      raise err if ::Logging.raise_errors?
     end
 
     # Close all appenders
@@ -569,8 +585,7 @@ module Logging
   require libpath('logging/diagnostic_context')
 
   require libpath('logging/rails_compat')
-end  # module Logging
-
+end
 
 # This finalizer will close all the appenders that exist in the system.
 # This is needed for closing IO streams and connections to the syslog server

data/lib/logging/appender.rb

@@ -9,11 +9,6 @@ module Logging
 # Each subclass should provide a +write+ method that will write log
 # messages to the logging destination.
 #
-# A private +sync+ method is provided for use by subclasses. It is used to
-# synchronize writes to the logging destination, and can be used by
-# subclasses to synchronize the closing or flushing of the logging
-# destination.
-#
 class Appender
 
   attr_reader :name, :layout, :level, :filters
@@ -263,13 +258,9 @@ class Appender
     "<%s name=\"%s\">" % [self.class.name.sub(%r/^Logging::/, ''), self.name]
   end
 
-  # Returns the current Encoding for the appender or nil if an encoding has
-  # not been set.
-  #
-  def encoding
-    return @encoding if defined? @encoding
-    @encoding = Object.const_defined?(:Encoding) ? Encoding.default_external : nil
-  end
+  # Returns the current Encoding for the appender. The default external econding
+  # will be used if none is explicitly set.
+  attr_reader :encoding
 
   # Set the appender encoding to the given value. The value can either be an
   # Encoding instance or a String or Symbol referring to a valid encoding.
@@ -282,9 +273,9 @@ class Appender
   # Raises ArgumentError if the value is not a valid encoding.
   def encoding=( value )
     if value.nil?
-      @encoding = nil
+      @encoding = Encoding.default_external
     else
-      @encoding = Object.const_defined?(:Encoding) ? Encoding.find(value.to_s) : nil
+      @encoding = Encoding.find(value.to_s)
     end
   end
 
@@ -328,17 +319,6 @@ private
     nil
   end
 
-  # call-seq:
-  #    sync { block }
-  #
-  # Obtains an exclusive lock, runs the block, and releases the lock when
-  # the block completes. This method is re-entrant so that a single thread
-  # can call +sync+ multiple times without hanging the thread.
-  #
-  def sync( &block )
-    @mutex.synchronize(&block)
-  end
-
 end  # class Appender
 end  # module Logging
 

data/lib/logging/appenders/buffering.rb

@@ -79,7 +79,7 @@ module Logging::Appenders
       return self if @buffer.empty?
 
       ary = nil
-      sync {
+      @mutex.synchronize {
         ary = @buffer.dup
         @buffer.clear
       }
@@ -100,7 +100,7 @@ module Logging::Appenders
     # Clear the underlying buffer of all log events. These events will not be
     # appended to the logging destination; they will be lost.
     def clear!
-      sync { @buffer.clear }
+      @mutex.synchronize { @buffer.clear }
     end
 
     # Configure the levels that will trigger an immediate flush of the
@@ -285,7 +285,7 @@ module Logging::Appenders
         canonical_write(str)
       else
         str = str.force_encoding(encoding) if encoding && str.encoding != encoding
-        sync {
+        @mutex.synchronize {
           @buffer << str
         }
         flush_now = @buffer.length >= @auto_flushing || immediate?(event)

data/lib/logging/appenders/console.rb

@@ -22,17 +22,49 @@ module Logging::Appenders
     #
     def initialize( *args )
       name = self.class.name.split("::").last.downcase
-      io   = Object.const_get(name.upcase)
 
       opts = args.last.is_a?(Hash) ? args.pop : {}
       name = args.shift unless args.empty?
 
-      opts[:encoding] = io.external_encoding if io.respond_to? :external_encoding
+      io = open_fd
+      opts[:encoding] = io.external_encoding
 
       super(name, io, opts)
-    rescue NameError
-      raise RuntimeError, "Please do not use the `Logging::Appenders::Console` class directly - " +
-                          "use `Logging::Appenders::Stdout` and `Logging::Appenders::Stderr` instead"
+    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 reopened.
+    def reopen
+      @mutex.synchronize {
+        if defined? @io && @io
+          flush
+          @io.close rescue nil
+        end
+        @io = open_fd
+      }
+      super
+      self
+    end
+
+  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
   end
 
@@ -43,7 +75,6 @@ module Logging::Appenders
   Stderr = Class.new(Console)
 
   # Accessor / Factory for the Stdout appender.
-  #
   def self.stdout( *args )
     if args.empty?
       return self['stdout'] || ::Logging::Appenders::Stdout.new
@@ -52,7 +83,6 @@ module Logging::Appenders
   end
 
   # Accessor / Factory for the Stderr appender.
-  #
   def self.stderr( *args )
     if args.empty?
       return self['stderr'] || ::Logging::Appenders::Stderr.new

data/lib/logging/appenders/file.rb

@@ -2,14 +2,12 @@
 module Logging::Appenders
 
   # Accessor / Factory for the File appender.
-  #
   def self.file( *args )
     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,7 +23,6 @@ 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? :write
         raise TypeError, "expecting an IO object but got '#{io.class.name}'"
@@ -47,7 +43,6 @@ 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
@@ -61,16 +56,25 @@ module Logging::Appenders
       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 && str.encoding != encoding
-      @io.write str
+      @mutex.synchronize { @io.write str }
       self
     rescue StandardError => err
       handle_internal_error(err)
@@ -82,6 +86,5 @@ module Logging::Appenders
       ::Logging.log_internal {"appender #{name.inspect} has been disabled"}
       ::Logging.log_internal_error(err)
     end
-
-  end  # IO
-end  # Logging::Appenders
+  end
+end