logging 1.7.2 → 1.8.0

data/lib/logging/layout.rb

@@ -22,6 +22,7 @@ class Layout
   # * :string  => to_s
   # * :inspect => inspect
   # * :yaml    => to_yaml
+  # * :json    => MultiJson.encode(obj)
   #
   # If the format is not specified then the global object format is used
   # (see Logging#format_as). If the global object format is not specified
@@ -37,7 +38,7 @@ class Layout
     f = f.intern if f.instance_of? String
 
     @obj_format = case f
-                  when :inspect, :yaml; f
+                  when :inspect, :yaml, :json; f
                   else :string end
 
     b = opts.getopt(:backtrace, ::Logging.backtrace)
@@ -94,23 +95,38 @@ class Layout
       str << case @obj_format
              when :inspect; obj.inspect
              when :yaml; try_yaml(obj)
+             when :json; try_json(obj)
              else obj.to_s end
       str
     end
   end
 
-  # call-seq:
-  #    try_yaml( obj )
-  #
   # Attempt to format the _obj_ using yaml, but fall back to inspect style
   # formatting if yaml fails.
   #
+  # obj - The Object to format.
+  #
+  # Returns a String representation of the object.
+  #
   def try_yaml( obj )
     "\n#{obj.to_yaml}"
   rescue TypeError
     obj.inspect
   end
 
+  # Attempt to format the given object as a JSON string, but fall back to
+  # inspect formatting if JSON encoding fails.
+  #
+  # obj - The Object to format.
+  #
+  # Returns a String representation of the object.
+  #
+  def try_json( obj )
+    MultiJson.encode(obj)
+  rescue StandardError
+    obj.inspect
+  end
+
 end  # class Layout
 end  # module Logging
 

data/lib/logging/layouts/parseable.rb

@@ -64,12 +64,12 @@ module Logging::Layouts
   # follows:
   #
   #   ---
-  #   timestamp: 2009-04-17 16:15:42
+  #   timestamp: 2009-04-17T16:15:42
   #   level: INFO
   #   logger: Foo::Bar
   #   message: this is a log message
   #   ---
-  #   timestamp: 2009-04-17 16:15:43
+  #   timestamp: 2009-04-17T16:15:43
   #   level: ERROR
   #   logger: Foo
   #   message: <RuntimeError> Oooops!!
@@ -84,8 +84,8 @@ module Logging::Layouts
   # it line by line and parse the individual objects. Taking the same
   # example above the JSON output would be:
   #
-  #   {"timestamp":"2009-04-17 16:15:42","level":"INFO","logger":"Foo::Bar","message":"this is a log message"}
-  #   {"timestamp":"2009-04-17 16:15:43","level":"ERROR","logger":"Foo","message":"<RuntimeError> Oooops!!"}
+  #   {"timestamp":"2009-04-17T16:15:42","level":"INFO","logger":"Foo::Bar","message":"this is a log message"}
+  #   {"timestamp":"2009-04-17T16:15:43","level":"ERROR","logger":"Foo","message":"<RuntimeError> Oooops!!"}
   #
   # The output order of the fields is guaranteed to be the same as the order
   # specified in the _items_ list.
@@ -95,17 +95,19 @@ module Logging::Layouts
     # :stopdoc:
     # Arguments to sprintf keyed to directive letters
     DIRECTIVE_TABLE = {
-      'logger'    => 'event.logger',
-      'timestamp' => 'event.time',
-      'level'     => '::Logging::LNAMES[event.level]',
-      'message'   => 'format_obj(event.data)',
-      'file'      => 'event.file',
-      'line'      => 'event.line',
-      'method'    => 'event.method',
-      'pid'       => 'Process.pid',
-      'millis'    => 'Integer((event.time-@created_at)*1000)',
-      'thread_id' => 'Thread.current.object_id',
-      'thread'    => 'Thread.current[:name]'
+      'logger'    => 'event.logger'.freeze,
+      'timestamp' => 'iso8601_format(event.time)'.freeze,
+      'level'     => '::Logging::LNAMES[event.level]'.freeze,
+      'message'   => 'format_obj(event.data)'.freeze,
+      'file'      => 'event.file'.freeze,
+      'line'      => 'event.line'.freeze,
+      'method'    => 'event.method'.freeze,
+      'pid'       => 'Process.pid'.freeze,
+      'millis'    => 'Integer((event.time-@created_at)*1000)'.freeze,
+      'thread_id' => 'Thread.current.object_id'.freeze,
+      'thread'    => 'Thread.current[:name]'.freeze,
+      'mdc'       => 'Logging::MappedDiagnosticContext.context'.freeze,
+      'ndc'       => 'Logging::NestedDiagnosticContext.context'.freeze
     }
 
     # call-seq:
@@ -134,14 +136,12 @@ module Logging::Layouts
     #
     def self.create_json_format_method( layout )
       code = "undef :format if method_defined? :format\n"
-      code << "def format( event )\n\"{"
+      code << "def format( event )\nh = {\n"
 
-      args = []
       code << layout.items.map {|name|
-        args << "format_as_json(#{Parseable::DIRECTIVE_TABLE[name]})"
-        "\\\"#{name}\\\":%s"
-      }.join(',')
-      code << "}\\n\" % [#{args.join(', ')}]\nend"
+        "'#{name}' => #{Parseable::DIRECTIVE_TABLE[name]}"
+      }.join(",\n")
+      code << "\n}\nMultiJson.encode(h) << \"\\n\"\nend\n"
 
       (class << layout; self end).class_eval(code, __FILE__, __LINE__)
     end
@@ -201,18 +201,33 @@ module Logging::Layouts
       create_format_method
     end
 
-  private
-
-    # Take the given _value_ and format it into a JSON compatible string.
+    # Public: Take a given object and convert it into a format suitable for
+    # inclusion as a log message. The conversion allows the object to be more
+    # easily expressed in YAML or JSON form.
+    #
+    # If the object is an Exception, then this method will return a Hash
+    # containing the exception class name, message, and backtrace (if any).
     #
-    def format_as_json( value )
-      case value
-      when String, Integer, Float; value.inspect
-      when nil; 'null'
-      when Time; %Q{"#{iso8601_format(value)}"}
-      else %Q{"#{value.inspect}"} end
+    # obj - The Object to format
+    #
+    # Returns the formatted Object.
+    #
+    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
+      when Time
+        iso8601_format(obj)
+      else
+        obj
+      end
     end
 
+  private
+
     # Call the appropriate class level create format method based on the
     # style of this parseable layout.
     #

data/lib/logging/layouts/pattern.rb

@@ -65,7 +65,12 @@ module Logging::Layouts
   #  [T]  Used to output the name of the thread that generated the log event.
   #       Name can be specified using Thread.current[:name] notation. Output
   #       empty string if name not specified. This option helps to create
-  #       more human readable output for multithread application logs.
+  #       more human readable output for multi-threaded application logs.
+  #  [X]  Used to output values from the Mapped Diagnostic Context. Requires
+  #       a key name to lookup the value from the context. More details are
+  #       listed below.
+  #  [x]  Used to output values from the Nested Diagnostic Context. Supports
+  #       an optional context separator string. More details are listed below.
   #  [%]  The sequence '%%' outputs a single percent sign.
   #
   # The logger name directive 'c' accepts an optional precision that will
@@ -77,6 +82,23 @@ 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
+  # 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
+  # values from the mapped context.
+  #
+  #   %X{Cookie}      Insert the current session cookie
+  #   %X{X-Session}   Insert a session identifier
+  #
+  # For the Nested Diagnostic Context you need only include the directive
+  # once. All contexts currently in the stack will be added to the log message
+  # separated by spaces. If spaces are not your style, a separator string can
+  # be given, too.
+  #
+  #   %x      Insert all contexts separated by spaces
+  #   %x{, }  Insert all contexts separate by a comma and a space
+  #
   # By default the relevant information is output as is. However, with the
   # aid of format modifiers it is possible to change the minimum field width,
   # the maximum field width and justification.
@@ -103,15 +125,15 @@ module Logging::Layouts
   # Below are various format modifier examples for the category conversion
   # specifier.
   #
-  #  [%20c]      Left pad with spaces if the logger name is less than 20
+  #   %20c       Left pad with spaces if the logger name is less than 20
   #              characters long
-  #  [%-20c]     Right pad with spaces if the logger name is less than 20
+  #   %-20c      Right pad with spaces if the logger name is less than 20
   #              characters long
-  #  [%.30c]     Truncates the logger name if it is longer than 30 characters
-  #  [%20.30c]   Left pad with spaces if the logger name is shorter than
+  #   %.30c      Truncates the logger name if it is longer than 30 characters
+  #   %20.30c    Left pad with spaces if the logger name is shorter than
   #              20 characters. However, if the logger name is longer than
   #              30 characters, then truncate the name.
-  #  [%-20.30c]  Right pad with spaces if the logger name is shorter than
+  #   %-20.30c   Right pad with spaces if the logger name is shorter than
   #              20 characters. However, if the logger name is longer than
   #              30 characters, then truncate the name.
   #
@@ -141,6 +163,8 @@ module Logging::Layouts
       '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
 
@@ -151,7 +175,7 @@ module Logging::Layouts
     # * $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%])(?:\{(\d+)\})?)?(.*)/m
+    DIRECTIVE_RGXP = %r/([^%]*)(?:(%-?\d*(?:\.\d+)?)([a-zA-Z%])(?:\{([^\}]+)\})?)?(.*)/m
 
     # default date format
     ISO8601 = "%Y-%m-%d %H:%M:%S".freeze
@@ -167,7 +191,9 @@ module Logging::Layouts
       't' => :thread_id,
       'F' => :file,
       'L' => :line,
-      'M' => :method
+      'M' => :method,
+      'X' => :mdc,
+      'x' => :ndc
     }.freeze
 
     # call-seq:
@@ -226,10 +252,15 @@ module Logging::Layouts
           format_string << fmt
           args << DIRECTIVE_TABLE[m[3]].dup
           if m[4]
-            raise ArgumentError, "logger name precision must be an integer greater than zero: #{m[4]}" unless Integer(m[4]) > 0
-            args.last <<
-                ".split(::Logging::Repository::PATH_DELIMITER)" \
-                ".last(#{m[4]}).join(::Logging::Repository::PATH_DELIMITER)"
+            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?
@@ -247,6 +278,23 @@ module Logging::Layouts
             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?
@@ -254,6 +302,7 @@ module Logging::Layouts
           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]}'"

data/test/appenders/test_buffered_io.rb

@@ -1,3 +1,4 @@
+# encoding: UTF-8
 
 require File.expand_path('../setup', File.dirname(__FILE__))
 
@@ -161,6 +162,26 @@ module TestAppenders
       assert_nil(readline)
     end
 
+    if Object.const_defined?(:Encoding)
+      def test_force_encoding
+        a = 'ümlaut'
+        b = 'hello ümlaut'.force_encoding('BINARY')
+
+        event_a = Logging::LogEvent.new('TestLogger', @levels['info'], a, false)
+        event_b = Logging::LogEvent.new('TestLogger', @levels['info'], b, false)
+
+        @appender.append event_a
+        @appender.append event_b
+        assert_nil(readline)
+
+        @appender.append event_a
+        assert_equal " INFO  TestLogger : #{a}\n", readline
+        assert_equal " INFO  TestLogger : #{b.force_encoding('UTF-8')}\n", readline
+        assert_equal " INFO  TestLogger : #{a}\n", readline
+        assert_nil(readline)
+      end
+    end
+
   private
     def readline
       @appender.readline

data/test/appenders/test_file.rb

@@ -1,3 +1,4 @@
+# encoding: UTF-8
 
 require File.expand_path('../setup', File.dirname(__FILE__))
 
@@ -95,6 +96,25 @@ module TestAppenders
       end
     end
 
+    if Object.const_defined? :Encoding
+
+      def test_encoding
+        log = File.join(TMP, 'file-encoding.log')
+        #appender = Logging.appenders.file(NAME, :filename => log, :encoding => 'ISO-8859-16')
+        appender = Logging.appenders.file(NAME, :filename => log, :encoding => 'ASCII')
+
+        appender << "A normal line of text\n"
+        appender << "ümlaut\n"
+        appender.close
+
+        lines = File.readlines(log)
+        assert_equal "A normal line of text\n", lines[0]
+        assert_equal "ümlaut\n", lines[1]
+
+        cleanup
+      end
+    end
+
   private
     def cleanup
       unless Logging.appenders[NAME].nil?

data/test/appenders/test_syslog.rb

@@ -52,12 +52,9 @@ module TestAppenders
       Process.waitpid(pid)
 
       if defined?(::Syslog::LOG_PERROR)
-        assert_equal("syslog_test:  INFO  TestLogger : <Array> #{[1,2,3,4]}\n",
-                     stderr[0].gets)
-        assert_equal("syslog_test: DEBUG  TestLogger : the big log message\n",
-                     stderr[0].gets)
-        assert_equal("syslog_test:  WARN  TestLogger : this is your last warning\n",
-                     stderr[0].gets)
+        assert_match(%r/INFO  TestLogger : <Array> #{Regexp.escape [1,2,3,4].to_s}/, stderr[0].gets)
+        assert_match(%r/DEBUG  TestLogger : the big log message/, stderr[0].gets)
+        assert_match(%r/WARN  TestLogger : this is your last warning/, stderr[0].gets)
       end
     end
 
@@ -101,9 +98,9 @@ module TestAppenders
       Process.waitpid(pid)
 
       if defined?(::Syslog::LOG_PERROR)
-        assert_equal("syslog_test: this is a test message\n", stderr[0].gets)
-        assert_equal("syslog_test: this is another message\n", stderr[0].gets)
-        assert_equal("syslog_test: some other line\n", stderr[0].gets)
+        assert_match(%r/this is a test message/, stderr[0].gets)
+        assert_match(%r/this is another message/, stderr[0].gets)
+        assert_match(%r/some other line/, stderr[0].gets)
       end
     end
 

data/test/layouts/test_json.rb

@@ -22,29 +22,37 @@ module TestLayouts
     end
 
     def test_format
-      fmt = %Q[\\{"timestamp":"#@date_fmt","level":"%s","logger":"%s","message":"%s"\\}\\n]
-
       event = Logging::LogEvent.new('ArrayLogger', @levels['info'],
                                     'log message', false)
-      rgxp  = Regexp.new(sprintf(fmt, 'INFO', 'ArrayLogger', 'log message'))
-      assert_match rgxp, @layout.format(event)
+      format = @layout.format(event)
+      assert_match %r/"timestamp":"#@date_fmt"/, format
+      assert_match %r/"level":"INFO"/, format
+      assert_match %r/"logger":"ArrayLogger"/, format
+      assert_match %r/"message":"log message"/, format
 
       event.data = [1, 2, 3, 4]
-      rgxp  = Regexp.new(sprintf(fmt, 'INFO', 'ArrayLogger',
-                                 Regexp.escape("<Array> #{[1,2,3,4]}")))
-      assert_match rgxp, @layout.format(event)
+      format = @layout.format(event)
+      assert_match %r/"timestamp":"#@date_fmt"/, format
+      assert_match %r/"level":"INFO"/, format
+      assert_match %r/"logger":"ArrayLogger"/, format
+      assert_match %r/"message":\[1,2,3,4\]/, format
 
       event.level = @levels['debug']
       event.data = 'and another message'
-      rgxp  = Regexp.new(sprintf(fmt, 'DEBUG', 'ArrayLogger',
-                         'and another message'))
-      assert_match rgxp, @layout.format(event)
+      format = @layout.format(event)
+      assert_match %r/"timestamp":"#@date_fmt"/, format
+      assert_match %r/"level":"DEBUG"/, format
+      assert_match %r/"logger":"ArrayLogger"/, format
+      assert_match %r/"message":"and another message"/, format
 
       event.logger = 'Test'
       event.level = @levels['fatal']
       event.data = Exception.new
-      rgxp  = Regexp.new(sprintf(fmt, 'FATAL', 'Test', '<Exception> Exception'))
-      assert_match rgxp, @layout.format(event)
+      format = @layout.format(event)
+      assert_match %r/"timestamp":"#@date_fmt"/, format
+      assert_match %r/"level":"FATAL"/, format
+      assert_match %r/"logger":"Test"/, format
+      assert_match %r/"message":\{(?:"(?:class|message)":"Exception",?){2}\}/, format
     end
 
     def test_items
@@ -103,6 +111,56 @@ module TestLayouts
       assert_equal %Q[{"thread":null}\n], @layout.format(event)
       Thread.current[:name] = "Main"
       assert_equal %Q[{"thread":"Main"}\n], @layout.format(event)
+
+      @layout.items = %w[mdc]
+      assert_match %r/\A\{"mdc":\{\}\}\n\z/, @layout.format(event)
+
+      @layout.items = %w[ndc]
+      assert_match %r/\A\{"ndc":\[\]\}\n\z/, @layout.format(event)
+    end
+
+    def test_mdc_output
+      event = Logging::LogEvent.new('TestLogger', @levels['info'],
+                                    'log message', false)
+      Logging.mdc['X-Session'] = '123abc'
+      Logging.mdc['Cookie'] = 'monster'
+
+      @layout.items = %w[timestamp level logger message mdc]
+
+      format = @layout.format(event)
+      assert_match %r/"timestamp":"#@date_fmt"/, format
+      assert_match %r/"level":"INFO"/, format
+      assert_match %r/"logger":"TestLogger"/, format
+      assert_match %r/"message":"log message"/, format
+      assert_match %r/"mdc":\{(?:(?:"X-Session":"123abc"|"Cookie":"monster"),?){2}\}/, format
+
+      Logging.mdc.delete 'Cookie'
+      format = @layout.format(event)
+      assert_match %r/"mdc":\{"X-Session":"123abc"\}/, format
+    end
+
+    def test_ndc_output
+      event = Logging::LogEvent.new('TestLogger', @levels['info'],
+                                    'log message', false)
+      Logging.ndc << 'context a'
+      Logging.ndc << 'context b'
+
+      @layout.items = %w[timestamp level logger message ndc]
+
+      format = @layout.format(event)
+      assert_match %r/"timestamp":"#@date_fmt"/, format
+      assert_match %r/"level":"INFO"/, format
+      assert_match %r/"logger":"TestLogger"/, format
+      assert_match %r/"message":"log message"/, format
+      assert_match %r/"ndc":\["context a","context b"\]/, format
+
+      Logging.ndc.pop
+      format = @layout.format(event)
+      assert_match %r/"ndc":\["context a"\]/, format
+
+      Logging.ndc.pop
+      format = @layout.format(event)
+      assert_match %r/"ndc":\[\]/, format
     end
 
   end  # class TestJson