semantic_logger 2.17.0 → 2.18.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6d01095b46462b1fc9ea2b2d918a372bda406cd8
-  data.tar.gz: d6e2b86770aaaa606727efa5090028ffd0e6bcb5
+  metadata.gz: 60df9242109f0c836e1375c4c21d5b0a85165e34
+  data.tar.gz: 47e1799788d85898b1ff7501ba99e460c78a815f
 SHA512:
-  metadata.gz: 0ec5d70d0147dba2cb7c63a1981de782a215036adbf469c48d2cb04a1c66a59b055fbf0627214464f0d12199679b69b2ddcd62fc93bf6017311a1cda730e5f90
-  data.tar.gz: 84d8f9e36d3ca6d04849e765a6cab837a281bdbcb625d4afebdecbe9d0d30bf86ac0f9153726bb9a726f702d8b22f4551ad782e2c25f285b89ff3bb17b9f0a0b
+  metadata.gz: 304af80d0e158f72a2dd5a90f8ac1e56dd8955bcfd26b4cec84862c0347ba5fb5b93ae4d6e76cdf6f48f3f84bb6310c9dfa703f36534bc253c64020d91576cd2
+  data.tar.gz: 0b1064e891a59877f1e991a19e73e2a1f10aac25e4621df25c311bd7d903df68144df37a88d5bc13b6e456a86446d14e43ad5834fa5009e2eb651745de5d0e6c

data/README.md

@@ -1,5 +1,5 @@
 # semantic_logger
-[![Gem Version](https://img.shields.io/gem/v/semantic_logger.svg)](https://rubygems.org/gems/semantic_logger) [![Build Status](https://travis-ci.org/rocketjob/semantic_logger.svg?branch=master)](https://travis-ci.org/rocketjob/semantic_logger) [![Downloads](https://img.shields.io/gem/dt/semantic_logger.svg)](https://rubygems.org/gems/semantic_logger) [![License](https://img.shields.io/badge/license-Apache%202.0-brightgreen.svg)](http://opensource.org/licenses/Apache-2.0) ![](https://img.shields.io/badge/status-Production%20Ready-blue.svg) [![Gitter chat](https://img.shields.io/badge/IRC%20(gitter)-Support-brightgreen.svg)](https://gitter.im/rocketjob/rocketjob)
+[![Gem Version](https://img.shields.io/gem/v/semantic_logger.svg)](https://rubygems.org/gems/semantic_logger) [![Build Status](https://travis-ci.org/rocketjob/semantic_logger.svg?branch=master)](https://travis-ci.org/rocketjob/semantic_logger) [![Downloads](https://img.shields.io/gem/dt/semantic_logger.svg)](https://rubygems.org/gems/semantic_logger) [![License](https://img.shields.io/badge/license-Apache%202.0-brightgreen.svg)](http://opensource.org/licenses/Apache-2.0) ![](https://img.shields.io/badge/status-Production%20Ready-blue.svg) [![Gitter chat](https://img.shields.io/badge/IRC%20(gitter)-Support-brightgreen.svg)](https://gitter.im/rocketjob/support)
 
 Low latency, high throughput, enterprise-scale logging system for Ruby
 

data/Rakefile

@@ -18,7 +18,7 @@ end
 desc 'Run Test Suite'
 task :test do
   Rake::TestTask.new(:functional) do |t|
-    t.test_files = FileList['test/*_test.rb']
+    t.test_files = FileList['test/**/*_test.rb']
     t.verbose    = true
   end
 

data/lib/semantic_logger.rb

@@ -5,6 +5,7 @@ require 'semantic_logger/semantic_logger'
 # @formatter:off
 module SemanticLogger
   autoload :Base,               'semantic_logger/base'
+  autoload :Log,                'semantic_logger/log'
   autoload :Logger,             'semantic_logger/logger'
   autoload :Loggable,           'semantic_logger/loggable'
   autoload :DebugAsTraceLogger, 'semantic_logger/debug_as_trace_logger'

data/lib/semantic_logger/appender/base.rb

@@ -11,16 +11,27 @@ module SemanticLogger
 
     # Formatting & colors used by optional colorized_formatter
     module AnsiColors
-      CLEAR   = "\e[0m"
-      BOLD    = "\e[1m"
-      BLACK   = "\e[30m"
-      RED     = "\e[31m"
-      GREEN   = "\e[32m"
-      YELLOW  = "\e[33m"
-      BLUE    = "\e[34m"
-      MAGENTA = "\e[35m"
-      CYAN    = "\e[36m"
-      WHITE   = "\e[37m"
+      CLEAR     = "\e[0m"
+      BOLD      = "\e[1m"
+      BLACK     = "\e[30m"
+      RED       = "\e[31m"
+      GREEN     = "\e[32m"
+      YELLOW    = "\e[33m"
+      BLUE      = "\e[34m"
+      MAGENTA   = "\e[35m"
+      CYAN      = "\e[36m"
+      WHITE     = "\e[37m"
+
+      # Maps the log level to a color for colorized formatters
+      # Since this map is not frozen, it can be modified as needed
+      LEVEL_MAP = {
+        trace: MAGENTA,
+        debug: GREEN,
+        info:  CYAN,
+        warn:  BOLD,
+        error: RED,
+        fatal: RED
+      }
     end
 
     class Base < SemanticLogger::Base
@@ -32,69 +43,73 @@ module SemanticLogger
       #    2011-07-19 14:36:15.660 D [1149:ScriptThreadProcess] Rails -- Hello World
       def default_formatter
         Proc.new do |log|
-          tags = log.tags.collect { |tag| "[#{tag}]" }.join(' ') + ' ' if log.tags && (log.tags.size > 0)
+          # Header with date, time, log level and process info
+          entry = "#{log.formatted_time} #{log.level_to_s} [#{log.process_info}]"
 
-          message = log.message.to_s.dup
-          message << ' -- ' << log.payload.inspect unless log.payload.nil? || (log.payload.respond_to?(:empty?) && log.payload.empty?)
-          message << ' -- Exception: ' << "#{log.exception.class}: #{log.exception.message}\n#{(log.exception.backtrace || []).join("\n")}" if log.exception
+          # Tags
+          entry << ' ' << log.tags.collect { |tag| "[#{tag}]" }.join(' ') if log.tags && (log.tags.size > 0)
 
-          duration_str = log.duration ? "(#{'%.1f' % log.duration}ms) " : ''
+          # Duration
+          entry << " (#{log.duration_human})" if log.duration
 
-          file_name =
-            if log.backtrace || log.exception
-              backtrace  = log.backtrace || log.exception.backtrace
-              location   = backtrace[0].split('/').last
-              file, line = location.split(':')
-              " #{file}:#{line}"
-            end
+          # Class / app name
+          entry << " #{log.name}"
 
-          "#{SemanticLogger::Appender::Base.formatted_time(log.time)} #{log.level.to_s[0..0].upcase} [#{$$}:#{'%.50s' % log.thread_name}#{file_name}] #{tags}#{duration_str}#{log.name} -- #{message}"
+          # Log message
+          entry << " -- #{log.message}" if log.message
+
+          # Payload
+          unless log.payload.nil? || (log.payload.respond_to?(:empty?) && log.payload.empty?)
+            entry << ' -- ' << log.payload.inspect
+          end
+
+          # Exceptions
+          log.each_exception do |exception, i|
+            entry << (i == 0 ? ' -- Exception: ' : "\nCause: ")
+            entry << "#{exception.class}: #{exception.message}\n#{(exception.backtrace || []).join("\n")}"
+          end
+          entry
         end
       end
 
       # Optional log formatter to colorize log output
       # To use this formatter
-      #   SemanticLogger.add_appender($stdout, nil, &SemanticLogger::Logger.colorized_formatter)
+      #   SemanticLogger.add_appender($stdout, &SemanticLogger::Appender::Base.colorized_formatter)
       #
       #    2011-07-19 14:36:15.660 D [1149:ScriptThreadProcess] Rails -- Hello World
       def self.colorized_formatter
         Proc.new do |log|
-          colors = SemanticLogger::Appender::AnsiColors
-          tags   = log.tags.collect { |tag| "[#{colors::CYAN}#{tag}#{colors::CLEAR}]" }.join(' ') + ' ' if log.tags && (log.tags.size > 0)
+          colors      = SemanticLogger::Appender::AnsiColors
+          level_color = colors::LEVEL_MAP[log.level]
+
+          # Header with date, time, log level and process info
+          entry = "#{log.formatted_time} #{level_color}#{log.level_to_s}#{colors::CLEAR} [#{log.process_info}]"
 
-          message = log.message.to_s.dup
+          # Tags
+          entry << ' ' << log.tags.collect { |tag| "[#{level_color}#{tag}#{colors::CLEAR}]" }.join(' ') if log.tags && (log.tags.size > 0)
+
+          # Duration
+          entry << " (#{colors::BOLD}#{log.duration_human}#{colors::CLEAR})" if log.duration
+
+          # Class / app name
+          entry << " #{level_color}#{log.name}#{colors::CLEAR}"
+
+          # Log message
+          entry << " -- #{log.message}" if log.message
+
+          # Payload
           unless log.payload.nil? || (log.payload.respond_to?(:empty?) && log.payload.empty?)
             payload = log.payload
             payload = (defined?(AwesomePrint) && payload.respond_to?(:ai)) ? payload.ai(multiline: false) : payload.inspect
-            message << ' -- ' << payload
+            entry << ' -- ' << payload
+          end
+
+          # Exceptions
+          log.each_exception do |exception, i|
+            entry << (i == 0 ? ' -- Exception: ' : "\nCause: ")
+            entry << "#{colors::BOLD}#{exception.class}: #{exception.message}#{colors::CLEAR}\n#{(exception.backtrace || []).join("\n")}"
           end
-          message << ' -- Exception: ' << "#{colors::BOLD}#{log.exception.class}: #{log.exception.message}#{colors::CLEAR}\n#{(log.exception.backtrace || []).join("\n")}" if log.exception
-
-          duration_str = log.duration ? "(#{colors::BOLD}#{'%.1f' % log.duration}ms#{colors::CLEAR}) " : ''
-
-          level_color =
-            case log.level
-            when :trace
-              colors::MAGENTA
-            when :debug
-              colors::GREEN
-            when :info
-              colors::CYAN
-            when :warn
-              colors::BOLD
-            when :error, :fatal
-              colors::RED
-            end
-
-          file_name =
-            if log.backtrace || log.exception
-              backtrace = log.backtrace || log.exception.backtrace
-              location = backtrace[0].split('/').last
-              file, line = location.split(':')
-              " #{level_color}#{file}:#{line}#{colors::CLEAR}"
-            end
-
-          "#{SemanticLogger::Appender::Base.formatted_time(log.time)} #{level_color}#{colors::BOLD}#{log.level.to_s[0..0].upcase}#{colors::CLEAR} [#{$$}:#{'%.30s' % log.thread_name}#{file_name}] #{tags}#{duration_str}#{level_color}#{log.name}#{colors::CLEAR} -- #{message}"
+          entry
         end
       end
 
@@ -139,17 +154,18 @@ module SemanticLogger
         @level_index || 0
       end
 
-      # For JRuby include the Thread name rather than its id
       if defined? Java
         # Return the Time as a formatted string
         # JRuby only supports time in ms
         def self.formatted_time(time)
+          warn '[deprecated] SemanticLogger::Base.formatted_time is deprecated please use log.formatted_time'
           "#{time.strftime('%Y-%m-%d %H:%M:%S')}.#{'%03d' % (time.usec/1000)}"
         end
       else
         # Return the Time as a formatted string
         # Ruby MRI supports micro seconds
         def self.formatted_time(time)
+          warn '[deprecated] SemanticLogger::Base.formatted_time is deprecated please use log.formatted_time'
           "#{time.strftime('%Y-%m-%d %H:%M:%S')}.#{'%06d' % (time.usec)}"
         end
       end

data/lib/semantic_logger/appender/bugsnag.rb

@@ -56,7 +56,7 @@ class SemanticLogger::Appender::Bugsnag < SemanticLogger::Appender::Base
   # Returns [Hash] of parameters to send to Bugsnag.
   def default_formatter
     proc do |log|
-      h = {severity: log_level(log), tags: log.tags, class: log.name}
+      h           = {severity: log_level(log), tags: log.tags, class: log.name}
       h[:message] = log.message if log.exception
       h.merge!(log.payload) if log.payload
       h

data/lib/semantic_logger/appender/mongodb.rb

@@ -154,21 +154,25 @@ module SemanticLogger
             level_index: log.level_index,
           }
           document[:application] = application if application
-          document[:message]     = self.class.strip_colorizing(log.message) if log.message
+          document[:message]     = log.cleansed_message if log.message
           document[:duration]    = log.duration if log.duration
           document[:tags]        = log.tags if log.tags && (log.tags.size > 0)
           document[:payload]     = log.payload if log.payload
           if log.exception
-            document[:exception] = {
-              name:        log.exception.class.name,
-              message:     log.exception.message,
-              stack_trace: log.exception.backtrace
-            }
+            root = document
+            log.each_exception do |exception, i|
+              name       = i == 0 ? :exception : :cause
+              root[name] = {
+                name:        exception.class.name,
+                message:     exception.message,
+                stack_trace: exception.backtrace
+              }
+              root       = root[name]
+            end
           end
-          if log.backtrace || log.exception
-            backtrace              = log.backtrace || log.exception.backtrace
-            location               = backtrace[0].split('/').last
-            file, line             = location.split(':')
+
+          file, line = log.file_name_and_line
+          if file
             document[:file_name]   = file
             document[:line_number] = line.to_i
           end
@@ -176,11 +180,6 @@ module SemanticLogger
         end
       end
 
-      # Strip the standard Rails colorizing from the logged message
-      def self.strip_colorizing(message)
-        message.to_s.gsub(/(\e(\[([\d;]*[mz]?))?)?/, '').strip
-      end
-
       # Default host_name to use if none is supplied to the appenders initializer
       def self.host_name
         @@host_name ||= Socket.gethostname.split('.').first

data/lib/semantic_logger/appender/splunk.rb

@@ -40,8 +40,8 @@ class SemanticLogger::Appender::Splunk < SemanticLogger::Appender::Base
   def parse_options(options)
     @config = {
       scheme:   options[:scheme] || :https,
-      host:     options[:host]   || 'localhost',
-      port:     options[:port]   || 8089,
+      host:     options[:host] || 'localhost',
+      port:     options[:port] || 8089,
       username: options[:username],
       password: options[:password]
     }

data/lib/semantic_logger/appender/syslog.rb

@@ -239,7 +239,14 @@ module SemanticLogger
 
           message = log.message.to_s
           message << ' -- ' << log.payload.inspect if log.payload
-          message << ' -- ' << "#{log.exception.class}: #{log.exception.message}\n#{(log.exception.backtrace || []).join("\n")}" if log.exception
+          log.each_exception do |exception, i|
+            if i == 0
+              message << ' -- '
+            else
+              message << "\nCause: "
+            end
+            message << "#{exception.class}: #{exception.message}\n#{(exception.backtrace || []).join("\n")}"
+          end
 
           duration_str = log.duration ? "(#{'%.1f' % log.duration}ms) " : ''
 

data/lib/semantic_logger/base.rb

@@ -279,46 +279,6 @@ module SemanticLogger
       @level_index || SemanticLogger.default_level_index
     end
 
-    # Struct Log
-    #
-    # level
-    #   Log level of the supplied log call
-    #   :trace, :debug, :info, :warn, :error, :fatal
-    #
-    # thread_name
-    #   Name of the thread in which the logging call was called
-    #
-    # name
-    #   Class name supplied to the logging instance
-    #
-    # message
-    #   Text message to be logged
-    #
-    # payload
-    #   Optional Hash or Ruby Exception object to be logged
-    #
-    # time
-    #   The time at which the log entry was created
-    #
-    # duration
-    #   The time taken to complete a benchmark call
-    #
-    # tags
-    #   Any tags active on the thread when the log call was made
-    #
-    # level_index
-    #   Internal index of the log level
-    #
-    # exception
-    #   Ruby Exception object to log
-    #
-    # metric [Object]
-    #   Object supplied when benchmark_x was called
-    #
-    # backtrace [Array<String>]
-    #   The backtrace captured at source when the log level >= SemanticLogger.backtrace_level
-    Log = Struct.new(:level, :thread_name, :name, :message, :payload, :time, :duration, :tags, :level_index, :exception, :metric, :backtrace)
-
     # Whether to log the supplied message based on the current filter if any
     def include_message?(struct)
       return true if @filter.nil?
@@ -335,7 +295,7 @@ module SemanticLogger
       # Detect exception being logged
       if exception.nil? && payload.nil? && message.kind_of?(Exception)
         exception = message
-        message   = exception.inspect
+        message   = nil
       elsif exception.nil? && payload && payload.respond_to?(:backtrace) && payload.respond_to?(:message)
         # Under JRuby a java exception is not a Ruby Exception
         #   Java::JavaLang::ClassCastException.new.is_a?(Exception) => false

data/lib/semantic_logger/log.rb

@@ -0,0 +1,143 @@
+module SemanticLogger
+  # Log Struct
+  #
+  #   Structure for holding all log entries
+  #
+  # level
+  #   Log level of the supplied log call
+  #   :trace, :debug, :info, :warn, :error, :fatal
+  #
+  # thread_name
+  #   Name of the thread in which the logging call was called
+  #
+  # name
+  #   Class name supplied to the logging instance
+  #
+  # message
+  #   Text message to be logged
+  #
+  # payload
+  #   Optional Hash or Ruby Exception object to be logged
+  #
+  # time
+  #   The time at which the log entry was created
+  #
+  # duration
+  #   The time taken to complete a benchmark call
+  #
+  # tags
+  #   Any tags active on the thread when the log call was made
+  #
+  # level_index
+  #   Internal index of the log level
+  #
+  # exception
+  #   Ruby Exception object to log
+  #
+  # metric [Object]
+  #   Object supplied when benchmark_x was called
+  #
+  # backtrace [Array<String>]
+  #   The backtrace captured at source when the log level >= SemanticLogger.backtrace_level
+  Log = Struct.new(:level, :thread_name, :name, :message, :payload, :time, :duration, :tags, :level_index, :exception, :metric, :backtrace) do
+
+    MAX_EXCEPTIONS_TO_UNWRAP = 5
+    # Call the block for exception and any nested exception
+    def each_exception(&block)
+      # With thanks to https://github.com/bugsnag/bugsnag-ruby/blob/6348306e44323eee347896843d16c690cd7c4362/lib/bugsnag/notification.rb#L81
+      depth      = 0
+      exceptions = []
+      ex         = exception
+      while ex != nil && !exceptions.include?(ex) && exceptions.length < MAX_EXCEPTIONS_TO_UNWRAP
+        exceptions << ex
+        block.call(ex, depth)
+
+        depth += 1
+        ex    =
+          if ex.respond_to?(:cause) && ex.cause
+            ex.cause
+          elsif ex.respond_to?(:continued_exception) && ex.continued_exception
+            ex.continued_exception
+          elsif ex.respond_to?(:original_exception) && ex.original_exception
+            ex.original_exception
+          end
+      end
+    end
+
+    # Returns [String] duration of the log entry as a string
+    # Returns nil if their is no duration
+    # Java time precision does not include microseconds
+    if defined? JRuby
+      def duration_to_s
+        "#{duration.to_i}ms" if duration
+      end
+    else
+      def duration_to_s
+        return unless duration
+        duration < 10.0 ? "#{'%.3f' % duration}ms" : "#{'%.1f' % duration}ms"
+      end
+    end
+
+    # Returns [String] the duration in human readable form
+    def duration_human
+      return nil unless duration
+      seconds = duration / 1000
+      if seconds >= 86400.0 # 1 day
+        "#{(seconds / 86400).to_i}d #{Time.at(seconds).strftime('%-Hh %-Mm')}"
+      elsif seconds >= 3600.0 # 1 hour
+        Time.at(seconds).strftime('%-Hh %-Mm')
+      elsif seconds >= 60.0 # 1 minute
+        Time.at(seconds).strftime('%-Mm %-Ss')
+      elsif seconds >= 1.0 # 1 second
+        Time.at(seconds).strftime('%-Ss %Lms')
+      else
+        duration_to_s
+      end
+    end
+
+    # Returns [String] single character upper case log level
+    def level_to_s
+      level.to_s[0..0].upcase
+    end
+
+    # Returns [String] the available process info
+    # Example:
+    #    18934:thread 23 test_logging.rb:51
+    def process_info(thread_name_length = 30)
+      file, line = file_name_and_line
+      file_name  = " #{file}:#{line}" if file
+
+      "#{$$}:#{"%.#{thread_name_length}s" % thread_name}#{file_name}"
+    end
+
+    # Returns [String, String] the file_name and line_number from the backtrace supplied
+    # in either the backtrace or exception
+    def file_name_and_line
+      if backtrace || (exception && exception.backtrace)
+        stacktrace = backtrace || exception.backtrace
+        stacktrace[0].split('/').last.split(':')[0..1] if stacktrace && stacktrace.size > 0
+      end
+    end
+
+    # Strip the standard Rails colorizing from the logged message
+    def cleansed_message
+      message.to_s.gsub(/(\e(\[([\d;]*[mz]?))?)?/, '').strip
+    end
+
+    if defined? JRuby
+      # Return the Time as a formatted string
+      # JRuby only supports time in ms
+      def formatted_time
+        "#{time.strftime('%Y-%m-%d %H:%M:%S')}.#{'%03d' % (time.usec/1000)}"
+      end
+    else
+      # Return the Time as a formatted string
+      # Ruby MRI supports micro seconds
+      def formatted_time
+        "#{time.strftime('%Y-%m-%d %H:%M:%S')}.#{'%06d' % (time.usec)}"
+      end
+    end
+
+  end
+
+end

data/lib/semantic_logger/logger.rb

@@ -58,7 +58,7 @@ module SemanticLogger
     def self.flush
       return false unless appender_thread_active?
 
-      logger.debug "Flushing appenders with #{queue_size} log messages on the queue"
+      logger.trace "Flushing appenders with #{queue_size} log messages on the queue"
       reply_queue = Queue.new
       queue << {command: :flush, reply_queue: reply_queue}
       reply_queue.pop
@@ -174,7 +174,7 @@ module SemanticLogger
       # Should any appender fail to log or flush, the exception is logged and
       # other appenders will still be called
       Thread.current.name = 'SemanticLogger::AppenderThread'
-      logger.debug "V#{VERSION} Appender thread active"
+      logger.trace "V#{VERSION} Appender thread active"
       begin
         count = 0
         while message = queue.pop
@@ -200,7 +200,7 @@ module SemanticLogger
             when :flush
               SemanticLogger.appenders.each do |appender|
                 begin
-                  logger.debug "Appender thread: Flushing appender: #{appender.name}"
+                  logger.trace "Appender thread: Flushing appender: #{appender.name}"
                   appender.flush
                 rescue Exception => exc
                   logger.error "Appender thread: Failed to flush appender: #{appender.inspect}", exc
@@ -208,7 +208,7 @@ module SemanticLogger
               end
 
               message[:reply_queue] << true if message[:reply_queue]
-              logger.debug 'Appender thread: All appenders flushed'
+              logger.trace 'Appender thread: All appenders flushed'
             else
               logger.warn "Appender thread: Ignoring unknown command: #{message[:command]}"
             end
@@ -226,7 +226,7 @@ module SemanticLogger
         @@appender_thread = nil
         # This block may be called after the file handles have been released by Ruby
         begin
-          logger.debug 'Appender thread has stopped'
+          logger.trace 'Appender thread has stopped'
         rescue Exception
           nil
         end

data/lib/semantic_logger/version.rb

@@ -1,3 +1,3 @@
 module SemanticLogger #:nodoc
-  VERSION = '2.17.0'
+  VERSION = '2.18.0'
 end

data/test/appender/file_test.rb

@@ -14,12 +14,13 @@ module Appender
         @hash                        = {session_id: 'HSSKLEU@JDK767', tracking_number: 12345}
         @hash_str                    = @hash.inspect.sub("{", "\\{").sub("}", "\\}")
         @thread_name                 = Thread.current.name
+        @file_name_reg_exp           = RUBY_VERSION.to_f <= 2.0 ? ' (mock|file_test).rb:\d+' : ' file_test.rb:\d+'
       end
 
       describe 'format logs into text form' do
         it 'handle no message or payload' do
           @appender.debug
-          assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ D \[\d+:#{@thread_name}\] SemanticLogger::Appender::File -- \n/, @io.string
+          assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ D \[\d+:#{@thread_name}\] SemanticLogger::Appender::File\n/, @io.string
         end
 
         it 'handle message' do
@@ -37,18 +38,48 @@ module Appender
           assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ D \[\d+:#{@thread_name}\] SemanticLogger::Appender::File -- hello world -- #{@hash_str} -- Exception: StandardError: StandardError\n\n/, @io.string
         end
 
-        it 'handle exception only' do
+        it 'logs exception with nil backtrace' do
           @appender.debug StandardError.new('StandardError')
-          assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ D \[\d+:#{@thread_name}\] SemanticLogger::Appender::File -- #<StandardError: StandardError> -- Exception: StandardError: StandardError\n\n/, @io.string
+          assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ D \[\d+:#{@thread_name}\] SemanticLogger::Appender::File -- Exception: StandardError: StandardError\n\n/, @io.string
+        end
+
+        it 'handle nested exception' do
+          begin
+            raise StandardError, 'FirstError'
+          rescue Exception => e
+            begin
+              raise StandardError, 'SecondError'
+            rescue Exception => e2
+              @appender.debug e2
+            end
+          end
+          assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ D \[\d+:#{@thread_name} file_test.rb:\d+\] SemanticLogger::Appender::File -- Exception: StandardError: SecondError\n/, @io.string
+          assert_match /^Cause: StandardError: FirstError\n/, @io.string if Exception.instance_methods.include?(:cause)
+        end
+
+        it 'logs exception with empty backtrace' do
+          exc = StandardError.new('StandardError')
+          exc.set_backtrace([])
+          @appender.debug exc
+          assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ D \[\d+:#{@thread_name}\] SemanticLogger::Appender::File -- Exception: StandardError: StandardError\n\n/, @io.string
         end
       end
 
       describe 'for each log level' do
         # Ensure that any log level can be logged
         SemanticLogger::LEVELS.each do |level|
-          it "log #{level} information" do
-            @appender.send(level, 'hello world', @hash)
-            assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ \w \[\d+:#{@thread_name}\] SemanticLogger::Appender::File -- hello world -- #{@hash_str}\n/, @io.string
+          it "log #{level} with file_name" do
+            SemanticLogger.stub(:backtrace_level_index, 0) do
+              @appender.send(level, 'hello world', @hash)
+              assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ \w \[\d+:#{@thread_name}#{@file_name_reg_exp}\] SemanticLogger::Appender::File -- hello world -- #{@hash_str}\n/, @io.string
+            end
+          end
+
+          it "log #{level} without file_name" do
+            SemanticLogger.stub(:backtrace_level_index, 100) do
+              @appender.send(level, 'hello world', @hash)
+              assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ \w \[\d+:#{@thread_name}\] SemanticLogger::Appender::File -- hello world -- #{@hash_str}\n/, @io.string
+            end
           end
         end
       end
@@ -64,7 +95,7 @@ module Appender
 
             duration_str = log.duration ? " (#{'%.1f' % log.duration}ms)" : ''
 
-            "#{SemanticLogger::Appender::Base.formatted_time(log.time)} #{log.level.to_s.upcase} [#{$$}:#{log.thread_name}] #{tags}#{log.name} -- #{message}#{duration_str}"
+            "#{log.formatted_time} #{log.level.to_s.upcase} [#{$$}:#{log.thread_name}] #{tags}#{log.name} -- #{message}#{duration_str}"
           end
         end
 

data/test/appender/mongodb_test.rb

@@ -66,7 +66,7 @@ module Appender
         end
 
         it "handle message without payload" do
-          log = SemanticLogger::Base::Log.new(:debug)
+          log = SemanticLogger::Log.new(:debug)
           @appender.debug('hello world')
 
           document = @appender.collection.find_one

data/test/appender/splunk_test.rb

@@ -1,4 +1,4 @@
-require_relative 'test_helper'
+require_relative '../test_helper'
 
 # Unit Test for SemanticLogger::Appender::Splunk
 #

data/test/appender/wrapper_test.rb

@@ -3,66 +3,66 @@ require_relative '../test_helper'
 # Unit Test for SemanticLogger::Appender::Wrapper
 #
 module Appender
-class WrapperTest < Minitest::Test
-  describe SemanticLogger::Appender::Wrapper do
-    before do
-      @time        = Time.new
-      @mock_logger = MockLogger.new
-      @appender    = SemanticLogger::Appender::Wrapper.new(@mock_logger)
-      @hash        = {session_id: 'HSSKLEU@JDK767', tracking_number: 12345}
-      @hash_str    = @hash.inspect.sub("{", "\\{").sub("}", "\\}")
-    end
-
-    describe 'format logs into text form' do
-      it 'handle nil name, message and payload' do
-        log       = SemanticLogger::Logger::Log.new
-        log.time  = Time.now
-        log.level = :debug
-        @appender.log(log)
-        assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ D \[\d+:\]  -- /, @mock_logger.message
+  class WrapperTest < Minitest::Test
+    describe SemanticLogger::Appender::Wrapper do
+      before do
+        @time        = Time.new
+        @mock_logger = MockLogger.new
+        @appender    = SemanticLogger::Appender::Wrapper.new(@mock_logger)
+        @hash        = {session_id: 'HSSKLEU@JDK767', tracking_number: 12345}
+        @hash_str    = @hash.inspect.sub("{", "\\{").sub("}", "\\}")
       end
 
-      it 'handle nil message and payload' do
-        log       = SemanticLogger::Logger::Log.new
-        log.time  = Time.now
-        log.level = :debug
-        log.name  = 'class'
-        @appender.log(log)
-        assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ D \[\d+:\] class -- /, @mock_logger.message
-      end
+      describe 'format logs into text form' do
+        it 'handle nil name, message and payload' do
+          log       = SemanticLogger::Log.new
+          log.time  = Time.now
+          log.level = :debug
+          @appender.log(log)
+          assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ D \[\d+:\] /, @mock_logger.message
+        end
 
-      it 'handle nil payload' do
-        log         = SemanticLogger::Logger::Log.new
-        log.time    = Time.now
-        log.level   = :debug
-        log.name    = 'class'
-        log.message = 'hello world'
-        @appender.log(log)
-        assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ D \[\d+:\] class -- hello world/, @mock_logger.message
-      end
+        it 'handle nil message and payload' do
+          log       = SemanticLogger::Log.new
+          log.time  = Time.now
+          log.level = :debug
+          log.name  = 'class'
+          @appender.log(log)
+          assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ D \[\d+:\] class/, @mock_logger.message
+        end
 
-      it 'handle payload' do
-        log         = SemanticLogger::Logger::Log.new
-        log.time    = Time.now
-        log.level   = :debug
-        log.name    = 'class'
-        log.message = 'hello world'
-        log.payload = @hash
-        @appender.log(log)
-        assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ D \[\d+:\] class -- hello world -- #{@hash_str}/, @mock_logger.message
+        it 'handle nil payload' do
+          log         = SemanticLogger::Log.new
+          log.time    = Time.now
+          log.level   = :debug
+          log.name    = 'class'
+          log.message = 'hello world'
+          @appender.log(log)
+          assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ D \[\d+:\] class -- hello world/, @mock_logger.message
+        end
+
+        it 'handle payload' do
+          log         = SemanticLogger::Log.new
+          log.time    = Time.now
+          log.level   = :debug
+          log.name    = 'class'
+          log.message = 'hello world'
+          log.payload = @hash
+          @appender.log(log)
+          assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ D \[\d+:\] class -- hello world -- #{@hash_str}/, @mock_logger.message
+        end
       end
-    end
 
-    describe 'for each log level' do
-      # Ensure that any log level can be logged
-      Logger::Severity.constants.each do |level|
-        it "log #{level.downcase.to_sym} info" do
-          @appender.log SemanticLogger::Logger::Log.new(level.downcase.to_sym, 'thread', 'class', 'hello world', @hash, Time.now)
-          assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ \w \[\d+:thread\] class -- hello world -- #{@hash_str}/, @mock_logger.message
+      describe 'for each log level' do
+        # Ensure that any log level can be logged
+        Logger::Severity.constants.each do |level|
+          it "log #{level.downcase.to_sym} info" do
+            @appender.log SemanticLogger::Log.new(level.downcase.to_sym, 'thread', 'class', 'hello world', @hash, Time.now)
+            assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ \w \[\d+:thread\] class -- hello world -- #{@hash_str}/, @mock_logger.message
+          end
         end
       end
-    end
 
+    end
   end
 end
-end

data/test/logger_test.rb

@@ -133,13 +133,13 @@ class LoggerTest < Minitest::Test
               it "log #{level} info" do
                 assert_equal 'result', @logger.send("benchmark_#{level}".to_sym, 'hello world') { 'result' } # Measure duration of the supplied block
                 SemanticLogger.flush
-                assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:#{@thread_name}\] \(\d+\.\dms\) LoggerTest -- hello world/, @mock_logger.message
+                assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:#{@thread_name}\] \((\d+\.\d+)|(\d+)ms\) LoggerTest -- hello world/, @mock_logger.message
               end
 
               it "log #{level} info with payload" do
                 assert_equal 'result', @logger.send("benchmark_#{level}".to_sym, 'hello world', payload: @hash) { 'result' } # Measure duration of the supplied block
                 SemanticLogger.flush
-                assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:#{@thread_name}\] \(\d+\.\dms\) LoggerTest -- hello world -- #{@hash_str}/, @mock_logger.message
+                assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:#{@thread_name}\] \((\d+\.\d+)|(\d+)ms\) LoggerTest -- hello world -- #{@hash_str}/, @mock_logger.message
               end
 
               it "not log #{level} info when block is faster than :min_duration" do
@@ -151,7 +151,7 @@ class LoggerTest < Minitest::Test
               it "log #{level} info when block duration exceeds :min_duration" do
                 assert_equal 'result', @logger.send("benchmark_#{level}".to_sym, 'hello world', min_duration: 200, payload: @hash) { sleep 0.5; 'result' } # Measure duration of the supplied block
                 SemanticLogger.flush
-                assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:#{@thread_name}\] \(\d+\.\dms\) LoggerTest -- hello world -- #{@hash_str}/, @mock_logger.message
+                assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:#{@thread_name}\] \((\d+\.\d+)|(\d+)ms\) LoggerTest -- hello world -- #{@hash_str}/, @mock_logger.message
               end
 
               it "log #{level} info with an exception" do
@@ -159,7 +159,7 @@ class LoggerTest < Minitest::Test
                   @logger.send("benchmark_#{level}", 'hello world', payload: @hash) { raise RuntimeError.new("Test") } # Measure duration of the supplied block
                 end
                 SemanticLogger.flush
-                assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:#{@thread_name}#{@file_name_reg_exp}\] \(\d+\.\dms\) LoggerTest -- hello world -- Exception: RuntimeError: Test -- #{@hash_str}/, @mock_logger.message
+                assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:#{@thread_name}#{@file_name_reg_exp}\] \((\d+\.\d+)|(\d+)ms\) LoggerTest -- hello world -- Exception: RuntimeError: Test -- #{@hash_str}/, @mock_logger.message
               end
 
               it "change log #{level} info with an exception" do
@@ -167,14 +167,14 @@ class LoggerTest < Minitest::Test
                   @logger.send("benchmark_#{level}", 'hello world', payload: @hash, on_exception_level: :fatal) { raise RuntimeError.new("Test") } # Measure duration of the supplied block
                 end
                 SemanticLogger.flush
-                assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ F \[\d+:#{@thread_name}#{@file_name_reg_exp}\] \(\d+\.\dms\) LoggerTest -- hello world -- Exception: RuntimeError: Test -- #{@hash_str}/, @mock_logger.message
+                assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ F \[\d+:#{@thread_name}#{@file_name_reg_exp}\] \((\d+\.\d+)|(\d+)ms\) LoggerTest -- hello world -- Exception: RuntimeError: Test -- #{@hash_str}/, @mock_logger.message
               end
 
               it "log #{level} info with metric" do
                 metric_name = '/my/custom/metric'
                 assert_equal 'result', @logger.send("benchmark_#{level}".to_sym, 'hello world', metric: metric_name) { 'result' } # Measure duration of the supplied block
                 SemanticLogger.flush
-                assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:#{@thread_name}\] \(\d+\.\dms\) LoggerTest -- hello world/, @mock_logger.message
+                assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:#{@thread_name}\] \((\d+\.\d+)|(\d+)ms\) LoggerTest -- hello world/, @mock_logger.message
                 assert metric_name, $last_metric.metric
               end
 
@@ -182,7 +182,7 @@ class LoggerTest < Minitest::Test
                 SemanticLogger.stub(:backtrace_level_index, 0) do
                   assert_equal 'result', @logger.send("benchmark_#{level}".to_sym, 'hello world') { 'result' }
                   SemanticLogger.flush
-                  assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:#{@thread_name}#{@file_name_reg_exp}\] \(\d+\.\dms\) LoggerTest -- hello world/, @mock_logger.message
+                  assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:#{@thread_name}#{@file_name_reg_exp}\] \((\d+\.\d+)|(\d+)ms\) LoggerTest -- hello world/, @mock_logger.message
                 end
               end
             end
@@ -191,13 +191,13 @@ class LoggerTest < Minitest::Test
               it "log #{level} info" do
                 assert_equal 'result', @logger.benchmark(level, 'hello world') { 'result' } # Measure duration of the supplied block
                 SemanticLogger.flush
-                assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:#{@thread_name}\] \(\d+\.\dms\) LoggerTest -- hello world/, @mock_logger.message
+                assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:#{@thread_name}\] \((\d+\.\d+)|(\d+)ms\) LoggerTest -- hello world/, @mock_logger.message
               end
 
               it "log #{level} info with payload" do
                 assert_equal 'result', @logger.benchmark(level, 'hello world', payload: @hash) { 'result' } # Measure duration of the supplied block
                 SemanticLogger.flush
-                assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:#{@thread_name}\] \(\d+\.\dms\) LoggerTest -- hello world -- #{@hash_str}/, @mock_logger.message
+                assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:#{@thread_name}\] \((\d+\.\d+)|(\d+)ms\) LoggerTest -- hello world -- #{@hash_str}/, @mock_logger.message
               end
 
               it "not log #{level} info when block is faster than :min_duration" do
@@ -209,7 +209,7 @@ class LoggerTest < Minitest::Test
               it "log #{level} info when block duration exceeds :min_duration" do
                 assert_equal 'result', @logger.benchmark(level, 'hello world', min_duration: 200, payload: @hash) { sleep 0.5; 'result' } # Measure duration of the supplied block
                 SemanticLogger.flush
-                assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:#{@thread_name}\] \(\d+\.\dms\) LoggerTest -- hello world -- #{@hash_str}/, @mock_logger.message
+                assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:#{@thread_name}\] \((\d+\.\d+)|(\d+)ms\) LoggerTest -- hello world -- #{@hash_str}/, @mock_logger.message
               end
 
               it "log #{level} info with an exception" do
@@ -217,14 +217,14 @@ class LoggerTest < Minitest::Test
                   @logger.benchmark(level, 'hello world', payload: @hash) { raise RuntimeError.new('Test') } # Measure duration of the supplied block
                 end
                 SemanticLogger.flush
-                assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:#{@thread_name}#{@file_name_reg_exp}\] \(\d+\.\dms\) LoggerTest -- hello world -- Exception: RuntimeError: Test -- #{@hash_str}/, @mock_logger.message
+                assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:#{@thread_name}#{@file_name_reg_exp}\] \((\d+\.\d+)|(\d+)ms\) LoggerTest -- hello world -- Exception: RuntimeError: Test -- #{@hash_str}/, @mock_logger.message
               end
 
               it "log #{level} info with metric" do
                 metric_name = '/my/custom/metric'
                 assert_equal 'result', @logger.benchmark(level, 'hello world', metric: metric_name) { 'result' } # Measure duration of the supplied block
                 SemanticLogger.flush
-                assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:#{@thread_name}\] \(\d+\.\dms\) LoggerTest -- hello world/, @mock_logger.message
+                assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:#{@thread_name}\] \((\d+\.\d+)|(\d+)ms\) LoggerTest -- hello world/, @mock_logger.message
                 assert metric_name, $last_metric.metric
               end
 
@@ -232,7 +232,7 @@ class LoggerTest < Minitest::Test
                 SemanticLogger.stub(:backtrace_level_index, 0) do
                   assert_equal 'result', @logger.benchmark(level, 'hello world') { 'result' }
                   SemanticLogger.flush
-                  assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:#{@thread_name}#{@file_name_reg_exp}\] \(\d+\.\dms\) LoggerTest -- hello world/, @mock_logger.message
+                  assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:#{@thread_name}#{@file_name_reg_exp}\] \((\d+\.\d+)|(\d+)ms\) LoggerTest -- hello world/, @mock_logger.message
                 end
               end
             end
@@ -241,7 +241,7 @@ class LoggerTest < Minitest::Test
           it 'log when the block performs a return' do
             assert_equal 'Good', function_with_return(@logger)
             SemanticLogger.flush
-            assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ I \[\d+:#{@thread_name}\] \(\d+\.\dms\) LoggerTest -- hello world -- #{@hash_str}/, @mock_logger.message
+            assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ I \[\d+:#{@thread_name}\] \((\d+\.\d+)|(\d+)ms\) LoggerTest -- hello world -- #{@hash_str}/, @mock_logger.message
           end
 
           it 'not log at a level below the silence level' do
@@ -250,7 +250,7 @@ class LoggerTest < Minitest::Test
               @logger.warn "don't log me"
             end
             SemanticLogger.flush
-            assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ I \[\d+:#{@thread_name}\] \(\d+\.\dms\) LoggerTest -- hello world/, @mock_logger.message
+            assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ I \[\d+:#{@thread_name}\] \((\d+\.\d+)|(\d+)ms\) LoggerTest -- hello world/, @mock_logger.message
           end
 
           it 'log at a silence level below the default level' do
@@ -264,7 +264,7 @@ class LoggerTest < Minitest::Test
             assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ D \[\d+:#{@thread_name}\] LoggerTest -- hello world -- Calculations -- #{@hash_str}/, first_message
             SemanticLogger.flush
             # Only the last log message is kept in mock logger
-            assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ I \[\d+:#{@thread_name}\] \(\d+\.\dms\) LoggerTest -- hello world/, @mock_logger.message
+            assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ I \[\d+:#{@thread_name}\] \((\d+\.\d+)|(\d+)ms\) LoggerTest -- hello world/, @mock_logger.message
           end
         end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: semantic_logger
 version: !ruby/object:Gem::Version
-  version: 2.17.0
+  version: 2.18.0
 platform: ruby
 authors:
 - Reid Morrison
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-11-05 00:00:00.000000000 Z
+date: 2015-11-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sync_attr
@@ -62,6 +62,7 @@ files:
 - lib/semantic_logger/core_ext/thread.rb
 - lib/semantic_logger/debug_as_trace_logger.rb
 - lib/semantic_logger/jruby/garbage_collection_logger.rb
+- lib/semantic_logger/log.rb
 - lib/semantic_logger/loggable.rb
 - lib/semantic_logger/logger.rb
 - lib/semantic_logger/semantic_logger.rb