logging 1.8.2 → 2.0.0

data/lib/logging/appenders/string_io.rb

@@ -57,7 +57,7 @@ module Logging::Appenders
         @sio.truncate 0
       }
     end
-    alias :reset :clear
+    alias_method :reset, :clear
 
     %w[read readline readlines].each do|m|
       class_eval <<-CODE, __FILE__, __LINE__+1

data/lib/logging/appenders/syslog.rb

@@ -93,16 +93,16 @@ module Logging::Appenders
     #                  through LOG_LOCAL7.
     #
     def initialize( name, opts = {} )
-      @ident = opts.getopt(:ident, name)
-      @logopt = opts.getopt(:logopt, (LOG_PID | LOG_CONS), :as => Integer)
-      @facility = opts.getopt(:facility, LOG_USER, :as => Integer)
+      @ident = opts.fetch(:ident, name)
+      @logopt = Integer(opts.fetch(:logopt, (LOG_PID | LOG_CONS)))
+      @facility = Integer(opts.fetch(:facility, LOG_USER))
       @syslog = ::Syslog.open(@ident, @logopt, @facility)
 
       # provides a mapping from the default Logging levels
       # to the syslog levels
       @map = [LOG_DEBUG, LOG_INFO, LOG_WARNING, LOG_ERR, LOG_CRIT]
 
-      map = opts.getopt(:map)
+      map = opts.fetch(:map, nil)
       self.map = map unless map.nil?
 
       super

data/lib/logging/color_scheme.rb

@@ -1,10 +1,11 @@
-
 # color_scheme.rb
 #
 # Created by Jeremy Hinegardner on 2007-01-24
 # Copyright 2007.  All rights reserved
 #
-# This is Free Software.  See LICENSE and COPYING for details
+# This file is licensed under the terms of the MIT License.
+# See the README for licensing details.
+#
 
 module Logging
 
@@ -71,7 +72,7 @@ module Logging
     # end of this file. Multiple color codes can be aliased by grouping them
     # in an array as shown in the example above.
     #
-    # Since color schemes are primary intended to be used with the Pattern
+    # Since color schemes are primarily intended to be used with the Pattern
     # layout, there are a few special options of note. First the log levels
     # are enumerated in their own hash:
     #
@@ -239,6 +240,22 @@ module Logging
     ON_CYAN    = "\e[46m".freeze    # Set the terminal's background ANSI color to cyan.
     ON_WHITE   = "\e[47m".freeze    # Set the terminal's background ANSI color to white.
 
+    BRIGHT_RED        = "\e[1;31m".freeze    # Set the terminal's foreground ANSI color to bright red.
+    BRIGHT_GREEN      = "\e[1;32m".freeze    # Set the terminal's foreground ANSI color to bright green.
+    BRIGHT_YELLOW     = "\e[1;33m".freeze    # Set the terminal's foreground ANSI color to bright yellow.
+    BRIGHT_BLUE       = "\e[1;34m".freeze    # Set the terminal's foreground ANSI color to bright blue.
+    BRIGHT_MAGENTA    = "\e[1;35m".freeze    # Set the terminal's foreground ANSI color to bright magenta.
+    BRIGHT_CYAN       = "\e[1;36m".freeze    # Set the terminal's foreground ANSI color to bright cyan.
+    BRIGHT_WHITE      = "\e[1;37m".freeze    # Set the terminal's foreground ANSI color to bright white.
+
+    ON_BRIGHT_RED     = "\e[1;41m".freeze    # Set the terminal's background ANSI color to bright red.
+    ON_BRIGHT_GREEN   = "\e[1;42m".freeze    # Set the terminal's background ANSI color to bright green.
+    ON_BRIGHT_YELLOW  = "\e[1;43m".freeze    # Set the terminal's background ANSI color to bright yellow.
+    ON_BRIGHT_BLUE    = "\e[1;44m".freeze    # Set the terminal's background ANSI color to bright blue.
+    ON_BRIGHT_MAGENTA = "\e[1;45m".freeze    # Set the terminal's background ANSI color to bright magenta.
+    ON_BRIGHT_CYAN    = "\e[1;46m".freeze    # Set the terminal's background ANSI color to bright cyan.
+    ON_BRIGHT_WHITE   = "\e[1;47m".freeze    # Set the terminal's background ANSI color to bright white.
+
   end  # ColorScheme
 
   # setup the default color scheme

data/lib/logging/diagnostic_context.rb

@@ -34,7 +34,10 @@ module Logging
     extend self
 
     # The name used to retrieve the MDC from thread-local storage.
-    NAME = 'logging.mapped-diagnostic-context'.freeze
+    NAME = :logging_mapped_diagnostic_context
+
+    # The name used to retrieve the MDC stack from thread-local storage.
+    STACK_NAME = :logging_mapped_diagnostic_context_stack
 
     # Public: Put a context value as identified with the key parameter into
     # the current thread's context map.
@@ -45,7 +48,8 @@ module Logging
     # Returns the value.
     #
     def []=( key, value )
-      context.store(key.to_s, value)
+      clear_context
+      peek.store(key.to_s, value)
     end
 
     # Public: Get the context value identified with the key parameter.
@@ -67,9 +71,52 @@ module Logging
     # present.
     #
     def delete( key )
-      context.delete(key.to_s)
+      clear_context
+      peek.delete(key.to_s)
+    end
+
+    # Public: Add all the key/value pairs from the given hash to the current
+    # mapped diagnostic context. The keys will be converted to strings.
+    # Existing keys of the same name will be overwritten.
+    #
+    # hash - The Hash of values to add to the current context.
+    #
+    # Returns this context.
+    #
+    def update( hash )
+      clear_context
+      sanitize(hash, peek)
+      self
+    end
+
+    # Public: Push a new Hash of key/value pairs onto the stack of contexts.
+    #
+    # hash - The Hash of values to push onto the context stack.
+    #
+    # Returns this context.
+    # Raises an ArgumentError if hash is not a Hash.
+    #
+    def push( hash )
+      clear_context
+      stack << sanitize(hash)
+      self
     end
 
+    # Public: Remove the most recently pushed Hash from the stack of contexts.
+    # If no contexts have been pushed then no action will be taken. The
+    # default context cannot be popped off the stack; please use the `clear`
+    # method if you want to remove all key/value pairs from the context.
+    #
+    # Returns nil or the Hash removed from the stack.
+    #
+    def pop
+      return unless Thread.current[STACK_NAME]
+      return unless stack.length > 1
+      clear_context
+      stack.pop
+    end
+
+
     # Public: Clear all mapped diagnostic information if any. This method is
     # useful in cases where the same thread can be potentially used over and
     # over in different unrelated contexts.
@@ -77,7 +124,8 @@ module Logging
     # Returns the MappedDiagnosticContext.
     #
     def clear
-      context.clear if Thread.current[NAME]
+      clear_context
+      Thread.current[STACK_NAME] = nil
       self
     end
 
@@ -92,24 +140,90 @@ module Logging
     def inherit( obj )
       case obj
       when Hash
-        Thread.current[NAME] = obj.dup
+        Thread.current[STACK_NAME] = [obj.dup]
       when Thread
         return if Thread.current == obj
         Thread.exclusive {
-          Thread.current[NAME] = obj[NAME].dup if obj[NAME]
+          if obj[STACK_NAME]
+            hash = flatten(obj[STACK_NAME])
+            Thread.current[STACK_NAME] = [hash]
+          end
         }
       end
 
       self
     end
 
-    # Returns the Hash acting as the storage for this NestedDiagnosticContext.
+    # Returns the Hash acting as the storage for this MappedDiagnosticContext.
     # A new storage Hash is created for each Thread running in the
     # application.
     #
     def context
-      Thread.current[NAME] ||= Hash.new
+      c = Thread.current[NAME]
+      return c unless c.nil?
+
+      return Thread.current[NAME] = {} unless Thread.current[STACK_NAME]
+
+      Thread.current[NAME] = flatten(stack)
+    end
+
+    # Returns the stack of Hash objects that are storing the diagnostic
+    # context information. This stack is guarnteed to always contain at least
+    # one Hash.
+    #
+    def stack
+      Thread.current[STACK_NAME] ||= [{}]
     end
+
+    # Returns the most current Hash from the stack of contexts.
+    #
+    def peek
+      stack.last
+    end
+
+    # Remove the flattened context.
+    #
+    def clear_context
+      Thread.current[NAME] = nil
+      self
+    end
+
+    # Given a Hash convert all keys into Strings. The values are not altered
+    # in any way. The converted keys and their values are stored in the target
+    # Hash if provided. Otherwise a new Hash is created and returned.
+    #
+    # hash   - The Hash of values to push onto the context stack.
+    # target - The target Hash to store the key value pairs.
+    #
+    # Returns a new Hash with all keys converted to Strings.
+    # Raises an ArgumentError if hash is not a Hash.
+    #
+    def sanitize( hash, target = {} )
+      unless Hash === hash
+        raise ArgumentError, "Expecting a Hash but received a #{hash.class.name}"
+      end
+
+      hash.each { |k,v| target[k.to_s] = v }
+      return target
+    end
+
+    # Given an Array of Hash objects, flatten all the key/value pairs from the
+    # Hash objects in the ary into a single Hash. The flattening occurs left
+    # to right. So that the key/value in the very last Hash overrides any
+    # other key from the previous Hash objcts.
+    #
+    # ary - An Array of Hash objects.
+    #
+    # Returns a Hash.
+    #
+    def flatten( ary )
+      return ary.first.dup if ary.length == 1
+
+      hash = {}
+      ary.each { |h| hash.update h }
+      return hash
+    end
+
   end  # MappedDiagnosticContext
 
 
@@ -154,7 +268,7 @@ module Logging
     extend self
 
     # The name used to retrieve the NDC from thread-local storage.
-    NAME = 'logging.nested-diagnostic-context'.freeze
+    NAME = :logging_nested_diagnostic_context
 
     # Public: Push new diagnostic context information for the current thread.
     # The contents of the message parameter is determined solely by the
@@ -166,9 +280,16 @@ module Logging
     #
     def push( message )
       context.push(message)
+      if block_given?
+        begin
+          yield
+        ensure
+          context.pop
+        end
+      end
       self
     end
-    alias :<< :push
+    alias_method :<<, :push
 
     # Public: Clients should call this method before leaving a diagnostic
     # context. The returned value is the last pushed message. If no
@@ -199,7 +320,7 @@ module Logging
     # Returns the NestedDiagnosticContext.
     #
     def clear
-      context.clear if Thread.current[NAME]
+      Thread.current[NAME] = nil
       self
     end
 
@@ -262,8 +383,9 @@ module Logging
     if all
       Thread.exclusive {
         Thread.list.each { |thread|
-          thread[MappedDiagnosticContext::NAME].clear if thread[MappedDiagnosticContext::NAME]
-          thread[NestedDiagnosticContext::NAME].clear if thread[NestedDiagnosticContext::NAME]
+          thread[MappedDiagnosticContext::NAME] = nil if thread[MappedDiagnosticContext::NAME]
+          thread[NestedDiagnosticContext::NAME] = nil if thread[NestedDiagnosticContext::NAME]
+          thread[MappedDiagnosticContext::STACK_NAME] = nil if thread[MappedDiagnosticContext::STACK_NAME]
         }
       }
     else
@@ -283,7 +405,7 @@ class Thread
 
     %w[new start fork].each do |m|
       class_eval <<-__, __FILE__, __LINE__
-        alias :_orig_#{m} :#{m}
+        alias_method :_orig_#{m}, :#{m}
         private :_orig_#{m}
         def #{m}( *a, &b )
           create_with_logging_context(:_orig_#{m}, *a ,&b)
@@ -309,14 +431,17 @@ class Thread
     def create_with_logging_context( m, *a, &b )
       mdc, ndc = nil
 
-      if Thread.current[Logging::MappedDiagnosticContext::NAME]
-        mdc = Thread.current[Logging::MappedDiagnosticContext::NAME].dup
+      if Thread.current[Logging::MappedDiagnosticContext::STACK_NAME]
+        mdc = Logging::MappedDiagnosticContext.context.dup
       end
 
       if Thread.current[Logging::NestedDiagnosticContext::NAME]
-        ndc = Thread.current[Logging::NestedDiagnosticContext::NAME].dup
+        ndc = Logging::NestedDiagnosticContext.context.dup
       end
 
+      # This calls the actual `Thread#new` method to create the Thread instance.
+      # If your memory profiling tool says this method is leaking memory, then
+      # you are leaking Thread instances somewhere.
       self.send(m, *a) { |*args|
         Logging::MappedDiagnosticContext.inherit(mdc)
         Logging::NestedDiagnosticContext.inherit(ndc)

data/lib/logging/filter.rb

@@ -0,0 +1,18 @@
+module Logging
+
+  # The `Filter` class allows for filtering messages based on event
+  # properties independently of the standard minimum-level restriction.
+  #
+  # All other Filters inherit from this class, and must override the
+  # `allow` method to return the event if it should be allowed into the log.
+  # Otherwise the `allow` method should return `nil`.
+  class Filter
+
+    # Returns the event if it should be allowed into the log. Returns `nil` if
+    # the event should _not_ be allowed into the log. Subclasses should override
+    # this method and provide their own filtering semantics.
+    def allow( event )
+      event
+    end
+  end
+end

data/lib/logging/filters.rb

@@ -0,0 +1,4 @@
+module Logging
+  module Filters ; end
+  require libpath('logging/filters/level')
+end

data/lib/logging/filters/level.rb

@@ -0,0 +1,29 @@
+require 'set'
+
+module Logging
+  module Filters
+
+    # The `Level` filter class provides a simple level-based filtering mechanism
+    # that filters messages to only include those from an enumerated list of
+    # levels to log.
+    class Level < ::Logging::Filter
+
+      # Creates a new level filter that will only allow the given _levels_ to
+      # propagate through to the logging destination. The _levels_ should be
+      # given in symbolic form.
+      #
+      # Examples
+      #     Logging::Filters::Level.new(:debug, :info)
+      #
+      def initialize( *levels )
+        levels  = levels.map { |level| ::Logging::level_num(level) }
+        @levels = Set.new levels
+      end
+
+      def allow( event )
+        @levels.include?(event.level) ? event : nil
+      end
+
+    end
+  end
+end

data/lib/logging/layout.rb

@@ -34,14 +34,14 @@ class Layout
     default = ::Logging.const_defined?('OBJ_FORMAT') ?
               ::Logging::OBJ_FORMAT : nil
 
-    f = opts.getopt(:format_as, default)
+    f = opts.fetch(:format_as, default)
     f = f.intern if f.instance_of? String
 
     @obj_format = case f
                   when :inspect, :yaml, :json; f
                   else :string end
 
-    b = opts.getopt(:backtrace, ::Logging.backtrace)
+    b = opts.fetch(:backtrace, ::Logging.backtrace)
     @backtrace = case b
         when :on, 'on', true;    true
         when :off, 'off', false; false

data/lib/logging/layouts/parseable.rb

@@ -1,3 +1,4 @@
+require 'socket'
 
 module Logging::Layouts
 
@@ -39,6 +40,7 @@ module Logging::Layouts
   #                was issued.
   #   'method'     Used to output the method name where the logging request
   #                was issued.
+  #   'hostname'   Used to output the hostname
   #   'pid'        Used to output the process ID of the currently running
   #                program.
   #   'millis'     Used to output the number of milliseconds elapsed from
@@ -102,6 +104,7 @@ module Logging::Layouts
       'file'      => 'event.file'.freeze,
       'line'      => 'event.line'.freeze,
       'method'    => 'event.method'.freeze,
+      'hostname'  => "'#{Socket.gethostname}'".freeze,
       'pid'       => 'Process.pid'.freeze,
       'millis'    => 'Integer((event.time-@created_at)*1000)'.freeze,
       'thread_id' => 'Thread.current.object_id'.freeze,
@@ -180,8 +183,8 @@ module Logging::Layouts
     def initialize( opts = {} )
       super
       @created_at = Time.now
-      @style = opts.getopt(:style, 'json').to_s.intern
-      self.items = opts.getopt(:items, %w[timestamp level logger message])
+      @style = opts.fetch(:style, 'json').to_s.intern
+      self.items = opts.fetch(:items, %w[timestamp level logger message])
     end
 
     attr_reader :items

data/lib/logging/layouts/pattern.rb

@@ -1,14 +1,14 @@
-
 module Logging::Layouts
 
   # Accessor / Factory for the Pattern layout.
   #
+  # Returns a new Pattern layout instance
   def self.pattern( *args )
     return ::Logging::Layouts::Pattern if args.empty?
     ::Logging::Layouts::Pattern.new(*args)
   end
 
-  # A flexible layout configurable with pattern string.
+  # A flexible layout configurable via a conversion pattern string.
   #
   # The goal of this class is to format a LogEvent and return the results as
   # a String. The results depend on the conversion pattern.
@@ -57,6 +57,7 @@ module Logging::Layouts
   #       the log event.
   #  [M]  Used to output the method name where the logging request was
   #       issued.
+  #  [h]  Used to output the hostname
   #  [p]  Used to output the process ID of the currently running program.
   #  [r]  Used to output the number of milliseconds elapsed from the
   #       construction of the Layout until creation of the log event.
@@ -74,7 +75,7 @@ module Logging::Layouts
   #  [%]  The sequence '%%' outputs a single percent sign.
   #
   # The logger name directive 'c' accepts an optional precision that will
-  # only print the rightmost number of namespace identifiers for the logger.
+  # only print the rightmost number of name space identifiers for the logger.
   # By default the logger name is printed in full. For example, for the
   # logger name "Foo::Bar::Baz" the pattern %c{2} will output "Bar::Baz".
   #
@@ -150,184 +151,51 @@ module Logging::Layouts
 
     # :stopdoc:
 
-    # Arguments to sprintf keyed to directive letters
-    DIRECTIVE_TABLE = {
-      'c' => 'event.logger'.freeze,
-      'd' => 'format_date(event.time)'.freeze,
-      'F' => 'event.file'.freeze,
-      'l' => '::Logging::LNAMES[event.level]'.freeze,
-      'L' => 'event.line'.freeze,
-      'm' => 'format_obj(event.data)'.freeze,
-      'M' => 'event.method'.freeze,
-      'p' => 'Process.pid'.freeze,
-      'r' => 'Integer((event.time-@created_at)*1000).to_s'.freeze,
-      't' => 'Thread.current.object_id.to_s'.freeze,
-      'T' => 'Thread.current[:name]'.freeze,
-      'X' => :placeholder,
-      'x' => :placeholder,
-      '%' => :placeholder
-    }.freeze
-
-    # Matches the first directive encountered and the stuff around it.
-    #
-    # * $1 is the stuff before directive or "" if not applicable
-    # * $2 is the %#.# match within directive group
-    # * $3 is the directive letter
-    # * $4 is the precision specifier for the logger name
-    # * $5 is the stuff after the directive or "" if not applicable
-    DIRECTIVE_RGXP = %r/([^%]*)(?:(%-?\d*(?:\.\d+)?)([a-zA-Z%])(?:\{([^\}]+)\})?)?(.*)/m
-
     # default date format
-    ISO8601 = "%Y-%m-%d %H:%M:%S".freeze
-
-    # Human name aliases for directives - used for colorization of tokens
-    COLOR_ALIAS_TABLE = {
-      'c' => :logger,
-      'd' => :date,
-      'm' => :message,
-      'p' => :pid,
-      'r' => :time,
-      'T' => :thread,
-      't' => :thread_id,
-      'F' => :file,
-      'L' => :line,
-      'M' => :method,
-      'X' => :mdc,
-      'x' => :ndc
-    }.freeze
+    ISO8601 = "%Y-%m-%dT%H:%M:%S".freeze
 
     # call-seq:
-    #    Pattern.create_date_format_methods( pf )
+    #    Pattern.create_date_format_methods( pl )
     #
     # This method will create the +date_format+ method in the given Pattern
-    # Layout _pf_ based on the configured date patten and/or date method
+    # Layout _pl_ based on the configured date pattern and/or date method
     # specified by the user.
     #
-    def self.create_date_format_methods( pf )
+    def self.create_date_format_methods( pl )
       code = "undef :format_date if method_defined? :format_date\n"
       code << "def format_date( time )\n"
-      if pf.date_method.nil?
-        if pf.date_pattern =~ %r/%s/
+      if pl.date_method.nil?
+        if pl.date_pattern =~ %r/%s/
           code << <<-CODE
-            dp = '#{pf.date_pattern}'.gsub('%s','%06d' % time.usec)
+            dp = '#{pl.date_pattern}'.gsub('%s','%06d' % time.usec)
             time.strftime dp
           CODE
         else
-          code << "time.strftime '#{pf.date_pattern}'\n"
+          code << "time.strftime '#{pl.date_pattern}'\n"
         end
       else
-        code << "time.#{pf.date_method}\n"
+        code << "time.#{pl.date_method}\n"
       end
       code << "end\n"
       ::Logging.log_internal(0) {code}
 
-      pf._meta_eval(code, __FILE__, __LINE__)
+      pl._meta_eval(code, __FILE__, __LINE__)
     end
 
     # call-seq:
-    #    Pattern.create_format_method( pf )
+    #    Pattern.create_format_method( pl )
     #
-    # This method will create the +format+ method in the given Pattern
-    # Layout _pf_ based on the configured format pattern specified by the
+    # This method will create the `format` method in the given Pattern
+    # Layout `pl` based on the configured format pattern specified by the
     # user.
     #
-    def self.create_format_method( pf )
-      # Create the format(event) method
-      format_string = '"'
-      pattern = pf.pattern.dup
-      color_scheme = pf.color_scheme
-      args = []
-      name_map_count = 0
-
-      while true
-        m = DIRECTIVE_RGXP.match(pattern)
-        format_string << m[1] unless m[1].empty?
-
-        case m[3]
-        when '%'; format_string << '%%'
-        when 'c'
-          fmt = m[2] + 's'
-          fmt = color_scheme.color(fmt, COLOR_ALIAS_TABLE[m[3]]) if color_scheme and !color_scheme.lines?
-
-          format_string << fmt
-          args << DIRECTIVE_TABLE[m[3]].dup
-          if m[4]
-            precision = Integer(m[4]) rescue nil
-            if precision
-              raise ArgumentError, "logger name precision must be an integer greater than zero: #{precision}" unless precision > 0
-              args.last <<
-                  ".split(::Logging::Repository::PATH_DELIMITER)" \
-                  ".last(#{m[4]}).join(::Logging::Repository::PATH_DELIMITER)"
-            else
-              format_string << "{#{m[4]}}"
-            end
-          end
-        when 'l'
-          if color_scheme and color_scheme.levels?
-            name_map = ::Logging::LNAMES.map { |name| color_scheme.color(("#{m[2]}s" % name), name) }
-            var = "@name_map_#{name_map_count}"
-            pf.instance_variable_set(var.to_sym, name_map)
-            name_map_count += 1
-
-            format_string << '%s'
-            format_string << "{#{m[4]}}" if m[4]
-            args << "#{var}[event.level]"
-          else
-            format_string << m[2] + 's'
-            format_string << "{#{m[4]}}" if m[4]
-            args << DIRECTIVE_TABLE[m[3]]
-          end
-
-        when 'X'
-          raise ArgumentError, "MDC must have a key reference" unless m[4]
-          fmt = m[2] + 's'
-          fmt = color_scheme.color(fmt, COLOR_ALIAS_TABLE[m[3]]) if color_scheme and !color_scheme.lines?
-
-          format_string << fmt
-          args << "::Logging.mdc['#{m[4]}']"
-
-        when 'x'
-          fmt = m[2] + 's'
-          fmt = color_scheme.color(fmt, COLOR_ALIAS_TABLE[m[3]]) if color_scheme and !color_scheme.lines?
-
-          format_string << fmt
-          separator = m[4].to_s
-          separator = ' ' if separator.empty?
-          args << "::Logging.ndc.context.join('#{separator}')"
-
-        when *DIRECTIVE_TABLE.keys
-          fmt = m[2] + 's'
-          fmt = color_scheme.color(fmt, COLOR_ALIAS_TABLE[m[3]]) if color_scheme and !color_scheme.lines?
-
-          format_string << fmt
-          format_string << "{#{m[4]}}" if m[4]
-          args << DIRECTIVE_TABLE[m[3]]
-
-        when nil; break
-        else
-          raise ArgumentError, "illegal format character - '#{m[3]}'"
-        end
-
-        break if m[5].empty?
-        pattern = m[5]
-      end
+    def self.create_format_method( pl )
+      builder = FormatMethodBuilder.new(pl)
+      code = builder.build_code
 
-      format_string << '"'
+      ::Logging.log_internal(0) { code }
 
-      sprintf = "sprintf("
-      sprintf << format_string
-      sprintf << ', ' + args.join(', ') unless args.empty?
-      sprintf << ")"
-
-      if color_scheme and color_scheme.lines?
-        sprintf = "color_scheme.color(#{sprintf}, ::Logging::LNAMES[event.level])"
-      end
-
-      code = "undef :format if method_defined? :format\n"
-      code << "def format( event )\n#{sprintf}\nend\n"
-      ::Logging.log_internal(0) {code}
-
-      pf._meta_eval(code, __FILE__, __LINE__)
+      pl._meta_eval(code, __FILE__, __LINE__)
     end
     # :startdoc:
 
@@ -353,22 +221,22 @@ module Logging::Layouts
       super
       @created_at = Time.now
 
-      @date_pattern = opts.getopt(:date_pattern)
-      @date_method = opts.getopt(:date_method)
-      @date_pattern = ISO8601 if @date_pattern.nil? and @date_method.nil?
+      @date_pattern = opts.fetch(:date_pattern, nil)
+      @date_method = opts.fetch(:date_method, nil)
+      @date_pattern = ISO8601 if @date_pattern.nil? && @date_method.nil?
 
-      @pattern = opts.getopt(:pattern,
+      @pattern = opts.fetch(:pattern,
           "[%d] %-#{::Logging::MAX_LEVEL_LENGTH}l -- %c : %m\n")
 
-      cs_name = opts.getopt(:color_scheme)
+      cs_name = opts.fetch(:color_scheme, nil)
       @color_scheme =
           case cs_name
           when false, nil; nil
           when true; ::Logging::ColorScheme[:default]
           else ::Logging::ColorScheme[cs_name] end
 
-      Pattern.create_date_format_methods(self)
-      Pattern.create_format_method(self)
+      self.class.create_date_format_methods(self)
+      self.class.create_format_method(self)
     end
 
     attr_reader :pattern, :date_pattern, :date_method, :color_scheme
@@ -409,18 +277,291 @@ module Logging::Layouts
 
     # :stopdoc:
 
-    # call-seq:
-    #    _meta_eval( code )
-    #
-    # Evaluates the given string of _code_ if the singleton class of this
+    # Evaluates the given string of `code` if the singleton class of this
     # Pattern Layout object.
     #
+    # Returns this Pattern Layout instance.
     def _meta_eval( code, file = nil, line = nil )
       meta = class << self; self end
       meta.class_eval code, file, line
+      self
     end
-    # :startdoc:
 
-  end  # Pattern
-end  # Logging::Layouts
+    # This class is used to build the `format` method for the Pattern layout. It
+    # parses the user defined pattern and emits Ruby source code (as a string)
+    # that can be `eval`d in the context of the Pattern layout instance.
+    class FormatMethodBuilder
+      # Matches the first directive encountered and the stuff around it.
+      #
+      # * $1 is the stuff before directive or "" if not applicable
+      # * $2 is the %#.# match within directive group
+      # * $3 is the directive letter
+      # * $4 is the precision specifier for the logger name
+      # * $5 is the stuff after the directive or "" if not applicable
+      DIRECTIVE_RGXP = %r/([^%]*)(?:(%-?\d*(?:\.\d+)?)([a-zA-Z%])(?:\{([^\}]+)\})?)?(.*)/m
+
+      # Arguments to sprintf keyed to directive letters
+      DIRECTIVE_TABLE = {
+        'c' => 'event.logger'.freeze,
+        'd' => 'format_date(event.time)'.freeze,
+        'F' => 'event.file'.freeze,
+        'l' => '::Logging::LNAMES[event.level]'.freeze,
+        'L' => 'event.line'.freeze,
+        'm' => 'format_obj(event.data)'.freeze,
+        'M' => 'event.method'.freeze,
+        'h' => "'#{Socket.gethostname}'".freeze,
+        'p' => 'Process.pid'.freeze,
+        'r' => 'Integer((event.time-@created_at)*1000).to_s'.freeze,
+        't' => 'Thread.current.object_id.to_s'.freeze,
+        'T' => 'Thread.current[:name]'.freeze,
+        'X' => :placeholder,
+        'x' => :placeholder,
+        '%' => :placeholder
+      }.freeze
+
+      # Human name aliases for directives - used for colorization of tokens
+      COLOR_ALIAS_TABLE = {
+        'c' => :logger,
+        'd' => :date,
+        'm' => :message,
+        'h' => :hostname,
+        'p' => :pid,
+        'r' => :time,
+        'T' => :thread,
+        't' => :thread_id,
+        'F' => :file,
+        'L' => :line,
+        'M' => :method,
+        'X' => :mdc,
+        'x' => :ndc
+      }.freeze
+
+      attr_reader :layout
+      attr_accessor :pattern
+      attr_reader :color_scheme
+      attr_reader :sprintf_args
+      attr_reader :format_string
+      attr_accessor :name_map_count
+
+      # Creates the format method builder and initializes some variables from
+      # the given Patter layout instance.
+      #
+      # pattern_layout - The Pattern Layout instance
+      #
+      def initialize( pattern_layout )
+        @layout         = pattern_layout
+        @pattern        = layout.pattern.dup
+        @color_scheme   = layout.color_scheme
+
+        @sprintf_args   = []
+        @format_string  = '"'
+        @name_map_count = 0
+      end
+
+      # Returns `true` if the log messages should be colorized.
+      def colorize?
+        color_scheme && !color_scheme.lines?
+      end
+
+      # Returns `true` if the log messages should be colorized by line.
+      def colorize_lines?
+        color_scheme && color_scheme.lines?
+      end
 
+      # Returns `true` if the log levels have special colorization defined.
+      def colorize_levels?
+        color_scheme && color_scheme.levels?
+      end
+
+      # This method returns a String which can be `eval`d in the context of the
+      # Pattern layout. When it is `eval`d, a `format` method is defined in the
+      # Pattern layout.
+      #
+      # At the heart of the format method is `sprintf`. The conversion pattern
+      # specified in the Pattern layout is parsed and converted into a format
+      # string and corresponding arguments list. The format string and arguments
+      # are then processed by `sprintf` to format log events.
+      #
+      # Returns a Ruby code as a String.
+      def build_code
+        build_format_string
+
+        sprintf = "sprintf("
+        sprintf << format_string
+        sprintf << ', ' + sprintf_args.join(', ') unless sprintf_args.empty?
+        sprintf << ")"
+
+        if colorize_lines?
+          sprintf = "color_scheme.color(#{sprintf}, ::Logging::LNAMES[event.level])"
+        end
+
+        code = "undef :format if method_defined? :format\n"
+        code << "def format( event )\n#{sprintf}\nend\n"
+      end
+
+      # This method builds the format string used by `sprintf` to format log
+      # events. The conversion pattern given by the user is iteratively parsed
+      # by a regular expression into separate format directives. Each directive
+      # builds up the format string and the corresponding arguments list that
+      # will be formatted.
+      #
+      # The actual building of the format string is handled by separate
+      # directive specific methods. Those handlers also populate the arguments
+      # list passed to `sprintf`.
+      #
+      # Returns the format String.
+      def build_format_string
+        while true
+          match = DIRECTIVE_RGXP.match(pattern)
+          _, pre, format, directive, precision, post = *match
+
+          format_string << pre unless pre.empty?
+
+          case directive
+          when '%'; format_string << '%%'
+          when 'c'; handle_logger( format, directive, precision )
+          when 'l'; handle_level(  format, directive, precision )
+          when 'X'; handle_mdc(    format, directive, precision )
+          when 'x'; handle_ndc(    format, directive, precision )
+
+          when *DIRECTIVE_TABLE.keys
+            handle_directives(format, directive, precision)
+
+          when nil; break
+          else
+            raise ArgumentError, "illegal format character - '#{directive}'"
+          end
+
+          break if post.empty?
+          self.pattern = post
+        end
+
+        format_string << '"'
+      end
+
+      # Add the logger name to the `format_string` and the `sprintf_args`. The
+      # `slice` argument is a little interesting - this is the number of logger
+      # name segments to keep. If we have a logger named "Foo::Bar::Baz" and our
+      # `slice` is 2, then "Bar::Baz" will appear in the generated log message.
+      # So the `slice` selects the last two parts of the logger name.
+      #
+      # format    - format String
+      # directive - the directive character ('c')
+      # slice     - the number of name segments to keep
+      #
+      # Returns nil
+      def handle_logger( format, directive, slice )
+        fmt = format + 's'
+        fmt = color_scheme.color(fmt, COLOR_ALIAS_TABLE[directive]) if colorize?
+
+        format_string << fmt
+        sprintf_args << DIRECTIVE_TABLE[directive].dup
+
+        if slice
+          numeric = Integer(slice) rescue nil
+          if numeric
+            raise ArgumentError, "logger name slice must be an integer greater than zero: #{numeric}" unless numeric > 0
+            sprintf_args.last <<
+                ".split(::Logging::Repository::PATH_DELIMITER)" \
+                ".last(#{slice}).join(::Logging::Repository::PATH_DELIMITER)"
+          else
+            format_string << "{#{slice}}"
+          end
+        end
+
+        nil
+      end
+
+      # Add the log event level to the `format_string` and the `sprintf_args`.
+      # The color scheme is taken into account when formatting the log event
+      # level.
+      #
+      # format    - format String
+      # directive - the directive character ('l')
+      # precision - added back to the format string
+      #
+      # Returns nil
+      def handle_level( format, directive, precision )
+        if colorize_levels?
+          name_map = ::Logging::LNAMES.map { |name| color_scheme.color(("#{format}s" % name), name) }
+          var = "@name_map_#{name_map_count}"
+          layout.instance_variable_set(var.to_sym, name_map)
+          self.name_map_count += 1
+
+          format_string << '%s'
+          format_string << "{#{precision}}" if precision
+          sprintf_args << "#{var}[event.level]"
+        else
+          format_string << format + 's'
+          format_string << "{#{precision}}" if precision
+          sprintf_args << DIRECTIVE_TABLE[directive]
+        end
+
+        nil
+      end
+
+      # Add a Mapped Diagnostic Context to the `format_string` and the
+      # `sprintf_args`. Only one MDC value is added at a time, so this directive
+      # can appear multiple times using various keys.
+      #
+      # format    - format String
+      # directive - the directive character ('X')
+      # key       - which MDC value to add to the log message
+      #
+      # Returns nil
+      def handle_mdc( format, directive, key )
+        raise ArgumentError, "MDC must have a key reference" unless key
+        fmt = format + 's'
+        fmt = color_scheme.color(fmt, COLOR_ALIAS_TABLE[directive]) if colorize?
+
+        format_string << fmt
+        sprintf_args << "::Logging.mdc['#{key}']"
+
+        nil
+      end
+
+      # Add a Nested Diagnostic Context to the `format_string` and the
+      # `sprintf_args`. Since the NDC is an Array of values, the directive will
+      # appear only once in the conversion pattern. A `separator` is inserted
+      # between the values in generated log message.
+      #
+      # format    - format String
+      # directive - the directive character ('x')
+      # separator - used to separate the values in the NDC array
+      #
+      # Returns nil
+      def handle_ndc( format, directive, separator )
+        fmt = format + 's'
+        fmt = color_scheme.color(fmt, COLOR_ALIAS_TABLE[directive]) if colorize?
+
+        format_string << fmt
+        separator = separator.to_s
+        separator = ' ' if separator.empty?
+        sprintf_args << "::Logging.ndc.context.join('#{separator}')"
+
+        nil
+      end
+
+      # Handles the rest of the directives; none of these need any special
+      # handling.
+      #
+      # format    - format String
+      # directive - the directive character
+      # precision - added back to the format string
+      #
+      # Returns nil
+      def handle_directives( format, directive, precision )
+        fmt = format + 's'
+        fmt = color_scheme.color(fmt, COLOR_ALIAS_TABLE[directive]) if colorize?
+
+        format_string << fmt
+        format_string << "{#{precision}}" if precision
+        sprintf_args << DIRECTIVE_TABLE[directive]
+
+        nil
+      end
+    end
+    # :startdoc:
+
+  end
+end