logging 2.0.0 → 2.1.0

data/lib/logging/appenders/console.rb

@@ -1,44 +1,55 @@
-
 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 )
+      name = self.class.name.split("::").last.downcase
+      io   = Object.const_get(name.upcase)
+
       opts = Hash === args.last ? args.pop : {}
-      name = args.empty? ? 'stdout' : args.shift
+      name = args.shift unless args.empty?
 
-      opts[:encoding] = STDOUT.external_encoding if STDOUT.respond_to? :external_encoding
+      opts[:encoding] = io.external_encoding if io.respond_to? :external_encoding
 
-      super(name, STDOUT, opts)
+      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
-  end  # Stdout
+  end
+
+  # This class provides an Appender that can write to STDOUT.
+  Stdout = Class.new(Console)
 
+  # This class provides an Appender that can write to STDERR.
+  Stderr = Class.new(Console)
+
+  # 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
 
   # Accessor / Factory for the Stderr appender.
   #
@@ -48,34 +59,4 @@ module Logging::Appenders
     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
-
-      opts[:encoding] = STDERR.external_encoding if STDERR.respond_to? :external_encoding
-
-      super(name, STDERR, opts)
-    end
-  end  # Stderr
-end  # Logging::Appenders
-
+end

data/lib/logging/appenders/file.rb

@@ -4,7 +4,7 @@ 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
 

data/lib/logging/appenders/io.rb

@@ -28,13 +28,12 @@ module Logging::Appenders
     # 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)
@@ -55,7 +54,7 @@ module Logging::Appenders
 
       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
@@ -70,10 +69,15 @@ module Logging::Appenders
     #
     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
+      @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)
@@ -81,4 +85,3 @@ module Logging::Appenders
 
   end  # IO
 end  # Logging::Appenders
-

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
 
@@ -148,7 +148,7 @@ module Logging::Appenders
       return self if @io.nil?
 
       str = str.force_encoding(encoding) if encoding && str.encoding != encoding
-      @io.flock_sh { @io.syswrite str }
+      @io.flock_sh { @io.write str }
 
       if roll_required?
         @io.flock? {

data/lib/logging/appenders/syslog.rb

@@ -9,7 +9,7 @@ module Logging::Appenders
   # Accessor / Factory for the Syslog appender.
   #
   def self.syslog( *args )
-    return ::Logging::Appenders::Syslog if args.empty?
+    fail ArgumentError, '::Logging::Appenders::Syslog needs a name as first argument.' if args.empty?
     ::Logging::Appenders::Syslog.new(*args)
   end
 

data/lib/logging/diagnostic_context.rb

@@ -143,7 +143,7 @@ module Logging
         Thread.current[STACK_NAME] = [obj.dup]
       when Thread
         return if Thread.current == obj
-        Thread.exclusive {
+        DIAGNOSTIC_MUTEX.synchronize {
           if obj[STACK_NAME]
             hash = flatten(obj[STACK_NAME])
             Thread.current[STACK_NAME] = [hash]
@@ -338,7 +338,7 @@ module Logging
         Thread.current[NAME] = obj.dup
       when Thread
         return if Thread.current == obj
-        Thread.exclusive {
+        DIAGNOSTIC_MUTEX.synchronize {
           Thread.current[NAME] = obj[NAME].dup if obj[NAME]
         }
       end
@@ -381,7 +381,7 @@ module Logging
   #
   def self.clear_diagnostic_contexts( all = false )
     if all
-      Thread.exclusive {
+      DIAGNOSTIC_MUTEX.synchronize {
         Thread.list.each { |thread|
           thread[MappedDiagnosticContext::NAME] = nil if thread[MappedDiagnosticContext::NAME]
           thread[NestedDiagnosticContext::NAME] = nil if thread[NestedDiagnosticContext::NAME]
@@ -396,6 +396,8 @@ module Logging
     self
   end
 
+  DIAGNOSTIC_MUTEX = Mutex.new
+
 end  # module Logging
 
 

data/lib/logging/layout.rb

@@ -41,15 +41,28 @@ class Layout
                   when :inspect, :yaml, :json; f
                   else :string end
 
-    b = opts.fetch(:backtrace, ::Logging.backtrace)
-    @backtrace = case b
-        when :on, 'on', true;    true
-        when :off, 'off', false; false
-        else
-          raise ArgumentError, "backtrace must be true or false"
-        end
+    self.backtrace = opts.fetch(:backtrace, ::Logging.backtrace)
   end
 
+  # call-seq:
+  #    layout.backtrace = true
+  #
+  # Set the backtrace flag to the given value. This can be set to `true` or
+  # `false`.
+  #
+  def backtrace=( value )
+    @backtrace = case value
+      when :on, 'on', true;    true
+      when :off, 'off', false; false
+      else
+        raise ArgumentError, "backtrace must be `true` or `false`"
+      end
+  end
+
+  # Returns the backtrace setting.
+  attr_reader :backtrace
+  alias :backtrace? :backtrace
+
   # call-seq:
   #    format( event )
   #
@@ -85,7 +98,7 @@ class Layout
     when String; obj
     when Exception
       str = "<#{obj.class.name}> #{obj.message}"
-      if @backtrace && !obj.backtrace.nil?
+      if backtrace? && !obj.backtrace.nil?
         str << "\n\t" << obj.backtrace.join("\n\t")
       end
       str

data/lib/logging/layouts/pattern.rb

@@ -83,7 +83,7 @@ module Logging::Layouts
   # events is configured to generate tracing information. If this is not
   # the case these fields will always be empty.
   #
-  # The directives for include diagnostic context information in the log
+  # The directives for including diagnostic context information in the log
   # messages are X and x. For the Mapped Diagnostic Context the directive must
   # be accompanied by the key identifying the value to insert into the log
   # message. The X directive can appear multiple times to include multiple
@@ -166,12 +166,9 @@ module Logging::Layouts
       code << "def format_date( time )\n"
       if pl.date_method.nil?
         if pl.date_pattern =~ %r/%s/
-          code << <<-CODE
-            dp = '#{pl.date_pattern}'.gsub('%s','%06d' % time.usec)
-            time.strftime dp
-          CODE
+          code << "time.strftime('#{pl.date_pattern.gsub('%s','%6N')}')\n"
         else
-          code << "time.strftime '#{pl.date_pattern}'\n"
+          code << "time.strftime('#{pl.date_pattern}')\n"
         end
       else
         code << "time.#{pl.date_method}\n"

data/lib/logging/log_event.rb

@@ -11,7 +11,7 @@ module Logging
     # * $1 == filename
     # * $2 == line number
     # * $3 == method name (might be nil)
-    CALLER_RGXP = %r/([-\.\/\(\)\w]+):(\d+)(?::in `(\w+)')?/o
+    CALLER_RGXP = %r/([-\.\/\(\)\w]+):(\d+)(?::in `([^']+)')?/o
     #CALLER_INDEX = 2
     CALLER_INDEX = ((defined? JRUBY_VERSION and JRUBY_VERSION > '1.6') or (defined? RUBY_ENGINE and RUBY_ENGINE[%r/^rbx/i])) ? 1 : 2
     # :startdoc:

data/lib/logging/logger.rb

@@ -26,87 +26,97 @@ module Logging
 
     @mutex = Mutex.new  # :nodoc:
 
-    class << self
+    # Returns the root logger.
+    def self.root
+      ::Logging::Repository.instance[:root]
+    end
 
-      # Returns the root logger.
-      def root
-        ::Logging::Repository.instance[:root]
-      end
+    class << self
+      alias_method :instantiate, :new  # `instantiate` becomes the "real" `new`
+    end
 
-      alias_method :instantiate, :new  # the "real" new
+    # Overrides the new method such that only one Logger will be created
+    # for any given logger name.
+    def self.new( *args )
+      args.empty? ? super : self[args.shift]
+    end
 
-      # Overrides the new method such that only one Logger will be created
-      # for any given logger name.
-      def new( *args )
-        args.empty? ? super : self[args.shift]
-      end
+    # Returns a logger instance for the given name.
+    def self.[]( name )
+      repo = ::Logging::Repository.instance
+      name = repo.to_key(name)
+      logger = repo[name]
+      return logger unless logger.nil?
 
-      # Returns a logger instance for the given name.
-      def []( name )
-        repo = ::Logging::Repository.instance
-        name = repo.to_key(name)
+      @mutex.synchronize do
         logger = repo[name]
-        return logger unless logger.nil?
+        return logger unless logger.nil? # thread-safe double checking
 
-        @mutex.synchronize do
-          logger = repo[name]
-          return logger unless logger.nil? # thread-safe double checking
-
-          logger = instantiate(name)
-          repo[name] = logger
-          repo.children(name).each { |c| c.__send__(:parent=, logger) }
-          logger
-        end
+        logger = instantiate(name)
+        repo[name] = logger
+        repo.children(name).each { |child| child.__send__(:parent=, logger) }
+        logger
       end
+    end
 
-      # This is where the actual logging methods are defined. Two methods
-      # are created for each log level. The first is a query method used to
-      # determine if that perticular logging level is enabled. The second is
-      # the actual logging method that accepts a list of objects to be
-      # logged or a block. If a block is given, then the object returned
-      # from the block will be logged.
-      #
-      # Example
-      #
-      #    log = Logging::Logger['my logger']
-      #    log.level = :warn
-      #
-      #    log.info?                               # => false
-      #    log.warn?                               # => true
-      #    log.warn 'this is your last warning'
-      #    log.fatal 'I die!', exception
-      #
-      #    log.debug do
-      #      # expensive method to construct log message
-      #      msg
-      #    end
-      #
-      def define_log_methods( logger )
-        ::Logging::LEVELS.each do |name,num|
-          code =  "undef :#{name}  if method_defined? :#{name}\n"
-          code << "undef :#{name}? if method_defined? :#{name}?\n"
-
-          if logger.level > num
-            code << <<-CODE
-              def #{name}?( ) false end
-              def #{name}( data = nil ) false end
-            CODE
-          else
-            code << <<-CODE
-              def #{name}?( ) true end
-              def #{name}( data = nil )
-                data = yield if block_given?
-                log_event(::Logging::LogEvent.new(@name, #{num}, data, @caller_tracing))
-                true
-              end
-            CODE
-          end
+    # This is where the actual logging methods are defined. Two methods
+    # are created for each log level. The first is a query method used to
+    # determine if that perticular logging level is enabled. The second is
+    # the actual logging method that accepts a list of objects to be
+    # logged or a block. If a block is given, then the object returned
+    # from the block will be logged.
+    #
+    # Example
+    #
+    #    log = Logging::Logger['my logger']
+    #    log.level = :warn
+    #
+    #    log.info?                               # => false
+    #    log.warn?                               # => true
+    #    log.warn 'this is your last warning'
+    #    log.fatal 'I die!', exception
+    #
+    #    log.debug do
+    #      # expensive method to construct log message
+    #      msg
+    #    end
+    #
+    def self.define_log_methods( logger )
+      code = log_methods_for_level(logger.level)
+      logger._meta_eval(code, __FILE__, __LINE__)
+      logger
+    end
 
-          logger._meta_eval(code, __FILE__, __LINE__)
+    # This generator is used to define the log methods for the given `level`.
+    # This code is evaluated in the context of a Logger instance.
+    #
+    # Returns log methods as a String
+    def self.log_methods_for_level( level )
+      code = []
+      ::Logging::LEVELS.each do |name,num|
+        code << <<-CODE
+            undef :#{name}  if method_defined? :#{name}
+            undef :#{name}? if method_defined? :#{name}?
+        CODE
+
+        if level > num
+          code << <<-CODE
+            def #{name}?( ) false end
+            def #{name}( data = nil ) false end
+          CODE
+        else
+          code << <<-CODE
+            def #{name}?( ) true end
+            def #{name}( data = nil )
+              data = yield if block_given?
+              log_event(::Logging::LogEvent.new(@name, #{num}, data, @caller_tracing))
+              true
+            end
+          CODE
         end
-        logger
       end
-    end  # class << self
+      code.join("\n")
+    end
 
     attr_reader :name, :parent, :additive, :caller_tracing
 
@@ -197,7 +207,14 @@ module Logging
       lvl = Integer(lvl)
       return false if lvl < level
 
-      data = yield if block_given?
+      if data.nil?
+        if block_given?
+          data = yield
+        else
+          data = progname
+        end
+      end
+
       log_event(::Logging::LogEvent.new(@name, lvl, data, @caller_tracing))
       true
     end
@@ -292,6 +309,11 @@ module Logging
       self.level
     end
 
+    # Returns `true` if the logger has its own level defined.
+    def has_own_level?
+      !@level.nil?
+    end
+
     # Returns the list of appenders.
     #
     def appenders
@@ -353,17 +375,7 @@ module Logging
     #
     def clear_appenders( ) @appenders.clear end
 
-    # call-seq:
-    #     inspect    => string
-    #
-    # Returns a string representation of the logger.
-    #
-    def inspect
-      "<%s:0x%x name=\"%s\">" % [self.class.name, self.object_id, self.name]
-    end
-
-
-    protected
+  protected
 
     # call-seq:
     #    parent = ParentLogger
@@ -396,18 +408,26 @@ module Logging
     #
     # Recursively call this method on all our children loggers.
     #
-    def define_log_methods( force = false )
-      return if @level and !force
+    def define_log_methods( force = false, code = nil )
+      return if has_own_level? and !force
 
-      ::Logging::Logger.define_log_methods(self)
-      ::Logging::Repository.instance.children(name).each do |c|
-        c.define_log_methods
+      ::Logging::Logger._reentrant_mutex.synchronize do
+        ::Logging::Logger.define_log_methods(self)
+        ::Logging::Repository.instance.children(name).each do |child|
+          child.define_log_methods
+        end
       end
       self
     end
 
     # :stopdoc:
-    public
+  public
+
+    @reentrant_mutex = ReentrantMutex.new
+
+    def self._reentrant_mutex
+      @reentrant_mutex
+    end
 
     # call-seq:
     #    _meta_eval( code )
@@ -483,7 +503,7 @@ module Logging
       @appenders.each do |appender|
         str << indent_str
         str << '- '
-        str << appender.inspect
+        str << appender.to_s
         str << "\n"
       end