logging 2.0.0 → 2.3.0

data/lib/logging/layouts/parseable.rb

@@ -103,7 +103,7 @@ module Logging::Layouts
       'message'   => 'format_obj(event.data)'.freeze,
       'file'      => 'event.file'.freeze,
       'line'      => 'event.line'.freeze,
-      'method'    => 'event.method'.freeze,
+      'method'    => 'event.method_name'.freeze,
       'hostname'  => "'#{Socket.gethostname}'".freeze,
       'pid'       => 'Process.pid'.freeze,
       'millis'    => 'Integer((event.time-@created_at)*1000)'.freeze,
@@ -177,8 +177,9 @@ module Logging::Layouts
     #
     # Creates a new Parseable layout using the following options:
     #
-    #    :style  => :json or :yaml
-    #    :items  => %w[timestamp level logger message]
+    #    :style      => :json or :yaml
+    #    :items      => %w[timestamp level logger message]
+    #    :utc_offset =>  "-06:00" or -21600 or "UTC"
     #
     def initialize( opts = {} )
       super
@@ -218,10 +219,15 @@ module Logging::Layouts
     def format_obj( obj )
       case obj
       when Exception
-        h = { :class   => obj.class.name,
-              :message => obj.message }
-        h[:backtrace] = obj.backtrace if @backtrace && !obj.backtrace.nil?
-        h
+        hash = {
+          :class   => obj.class.name,
+          :message => obj.message
+        }
+        hash[:backtrace] = obj.backtrace if backtrace? && obj.backtrace
+
+        cause = format_cause(obj)
+        hash[:cause] = cause unless cause.empty?
+        hash
       when Time
         iso8601_format(obj)
       else
@@ -229,6 +235,37 @@ module Logging::Layouts
       end
     end
 
+    # Internal: Format any nested exceptions found in the given exception `e`
+    # while respecting the maximum `cause_depth`.
+    #
+    # e - Exception to format
+    #
+    # Returns the cause formatted as a Hash
+    def format_cause(e)
+      rv = curr = {}
+      prev = nil
+
+      cause_depth.times do
+        break unless e.respond_to?(:cause) && e.cause
+
+        cause = e.cause
+        curr[:class]     = cause.class.name
+        curr[:message]   = cause.message
+        curr[:backtrace] = format_cause_backtrace(e, cause) if backtrace? && cause.backtrace
+
+        prev[:cause] = curr unless prev.nil?
+        prev, curr = curr, {}
+
+        e = cause
+      end
+
+      if e.respond_to?(:cause) && e.cause
+        prev[:cause] = {message: "Further #cause backtraces were omitted"}
+      end
+
+      rv
+    end
+
   private
 
     # Call the appropriate class level create format method based on the
@@ -241,9 +278,11 @@ module Logging::Layouts
       else raise ArgumentError, "unknown format style '#@style'" end
     end
 
-    # Convert the given time _value_ into an ISO8601 formatted time string.
+    # Convert the given `time` into an ISO8601 formatted time string.
     #
-    def iso8601_format( value )
+    def iso8601_format( time )
+      value = apply_utc_offset(time)
+
       str = value.strftime('%Y-%m-%dT%H:%M:%S')
       str << ('.%06d' % value.usec)
 
@@ -254,6 +293,5 @@ module Logging::Layouts
       return str << (value.gmt_offset < 0 ? '-' : '+') << offset
     end
 
-  end  # Parseable
-end  # Logging::Layouts
-
+  end
+end

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
@@ -164,14 +164,12 @@ module Logging::Layouts
     def self.create_date_format_methods( pl )
       code = "undef :format_date if method_defined? :format_date\n"
       code << "def format_date( time )\n"
+      code << "time = apply_utc_offset(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"
@@ -206,7 +204,8 @@ module Logging::Layouts
     #
     #    :pattern       =>  "[%d] %-5l -- %c : %m\n"
     #    :date_pattern  =>  "%Y-%m-%d %H:%M:%S"
-    #    :date_method   =>  'usec' or 'to_s'
+    #    :date_method   =>  "usec" or "to_s"
+    #    :utc_offset    =>  "-06:00" or -21600 or "UTC"
     #    :color_scheme  =>  :default
     #
     # If used, :date_method will supersede :date_pattern.
@@ -219,7 +218,7 @@ module Logging::Layouts
     #
     def initialize( opts = {} )
       super
-      @created_at = Time.now
+      @created_at = Time.now.freeze
 
       @date_pattern = opts.fetch(:date_pattern, nil)
       @date_method = opts.fetch(:date_method, nil)
@@ -308,7 +307,7 @@ module Logging::Layouts
         'l' => '::Logging::LNAMES[event.level]'.freeze,
         'L' => 'event.line'.freeze,
         'm' => 'format_obj(event.data)'.freeze,
-        'M' => 'event.method'.freeze,
+        'M' => 'event.method_name'.freeze,
         'h' => "'#{Socket.gethostname}'".freeze,
         'p' => 'Process.pid'.freeze,
         'r' => 'Integer((event.time-@created_at)*1000).to_s'.freeze,

data/lib/logging/log_event.rb

@@ -2,8 +2,7 @@
 module Logging
 
   # This class defines a logging event.
-  #
-  LogEvent = Struct.new( :logger, :level, :data, :time, :file, :line, :method ) {
+  class LogEvent
     # :stopdoc:
 
     # Regular expression used to parse out caller information
@@ -11,11 +10,13 @@ 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:
 
+    attr_accessor :logger, :level, :data, :time, :file, :line, :method_name
+
     # call-seq:
     #    LogEvent.new( logger, level, [data], caller_tracing )
     #
@@ -25,20 +26,26 @@ module Logging
     # invoked to get the execution trace of the logging method.
     #
     def initialize( logger, level, data, caller_tracing )
-      f = l = m = ''
+      self.logger = logger
+      self.level  = level
+      self.data   = data
+      self.time   = Time.now.freeze
 
       if caller_tracing
         stack = Kernel.caller[CALLER_INDEX]
         return if stack.nil?
 
         match = CALLER_RGXP.match(stack)
-        f = match[1]
-        l = Integer(match[2])
-        m = match[3] unless match[3].nil?
+        self.file = match[1]
+        self.line = Integer(match[2])
+        self.method_name = match[3] unless match[3].nil?
+
+        if (bp = ::Logging.basepath) && !bp.empty? && file.index(bp) == 0
+          self.file = file.slice(bp.length + 1, file.length - bp.length)
+        end
+      else
+        self.file = self.line = self.method_name = ''
       end
-
-      super(logger, level, data, Time.now, f, l, m)
     end
-  }
-end  # module Logging
-
+  end
+end

data/lib/logging/logger.rb

@@ -24,89 +24,108 @@ module Logging
   #
   class Logger
 
-    @mutex = Mutex.new  # :nodoc:
+    # Returns the root logger.
+    def self.root
+      ::Logging::Repository.instance[:root]
+    end
 
     class << self
+      alias_method :instantiate, :new  # `instantiate` becomes the "real" `new`
+    end
 
-      # Returns the root logger.
-      def root
-        ::Logging::Repository.instance[:root]
-      end
+    # 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
 
-      alias_method :instantiate, :new  # the "real" new
+    # 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?
+
+      # Share the same mutex that's used by 'define_log_methods' because
+      # it iterates over the hash of loggers, and adding a new key to a hash
+      # while iterating over it produces an error.
+      ::Logging::Logger.mutex.synchronize do
+        logger = repo[name]
+        return logger unless logger.nil? # thread-safe double checking
 
-      # 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]
+        logger = instantiate(name)
+        repo[name] = logger
+        repo.children(name).each { |child| child.__send__(:parent=, logger) }
+        logger
       end
+    end
 
-      # Returns a logger instance for the given name.
-      def []( name )
-        repo = ::Logging::Repository.instance
-        name = repo.to_key(name)
-        logger = repo[name]
-        return logger unless logger.nil?
-
-        @mutex.synchronize do
-          logger = repo[name]
-          return logger unless logger.nil? # thread-safe double checking
+    # 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 = instantiate(name)
-          repo[name] = logger
-          repo.children(name).each { |c| c.__send__(:parent=, logger) }
-          logger
+    # 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
       end
+      code.join("\n")
+    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
+    @mutex = ReentrantMutex.new
 
-          logger._meta_eval(code, __FILE__, __LINE__)
-        end
-        logger
-      end
-    end  # class << self
+    # Returns a global ReentrantMutex for use when creating Logger instances
+    # and/or updating log levels.
+    def self.mutex
+      @mutex
+    end
 
     attr_reader :name, :parent, :additive, :caller_tracing
 
@@ -197,7 +216,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
@@ -247,7 +273,7 @@ module Logging
     #    level = :all
     #
     # Set the level for this logger. The level can be either a +String+, a
-    # +Symbol+, or a +Fixnum+. An +ArgumentError+ is raised if this is not
+    # +Symbol+, or an +Integer+. An +ArgumentError+ is raised if this is not
     # the case.
     #
     # There are two special levels -- "all" and "off". The former will
@@ -277,7 +303,7 @@ module Logging
         else
           lvl = case level
                 when String, Symbol; ::Logging::level_num(level)
-                when Fixnum; level
+                when Integer; level
                 else
                   raise ArgumentError,
                         "level must be a String, Symbol, or Integer"
@@ -292,6 +318,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 +384,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 +417,20 @@ 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.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
 
     # call-seq:
     #    _meta_eval( code )
@@ -483,7 +506,7 @@ module Logging
       @appenders.each do |appender|
         str << indent_str
         str << '- '
-        str << appender.inspect
+        str << appender.to_s
         str << "\n"
       end
 
@@ -491,6 +514,5 @@ module Logging
     end
     # :startdoc:
 
-  end  # Logger
-end  # Logging
-
+  end
+end