logging 2.0.0 → 2.3.0

data/lib/logging/appenders/string_io.rb

@@ -62,7 +62,7 @@ module Logging::Appenders
     %w[read readline readlines].each do|m|
       class_eval <<-CODE, __FILE__, __LINE__+1
         def #{m}( *args )
-          sync {
+          @mutex.synchronize {
             begin
               @sio.seek @pos
               rv = @sio.#{m}(*args)

data/lib/logging/appenders/syslog.rb

@@ -9,7 +9,7 @@ module Logging::Appenders
   # Accessor / Factory for the Syslog appender.
   #
   def self.syslog( *args )
-    return ::Logging::Appenders::Syslog if args.empty?
+    fail ArgumentError, '::Logging::Appenders::Syslog needs a name as first argument.' if args.empty?
     ::Logging::Appenders::Syslog.new(*args)
   end
 
@@ -188,7 +188,7 @@ module Logging::Appenders
         end
       return if message.empty?
 
-      @syslog.log(pri, '%s', message)
+      @mutex.synchronize { @syslog.log(pri, '%s', message) }
       self
     end
 
@@ -205,11 +205,10 @@ module Logging::Appenders
         level = level.to_s.upcase
         self.class.const_get level
       else
-        raise ArgumentError, "unkonwn level '#{level}'"
+        raise ArgumentError, "unknown level '#{level}'"
       end
     end
 
   end  # Syslog
 end  # Logging::Appenders
 end  # HAVE_SYSLOG
-

data/lib/logging/color_scheme.rb

@@ -40,7 +40,7 @@ module Logging
       # Store a color scheme by name.
       #
       def []=( name, value )
-        raise ArgumentError, "Silly! That's not a ColorSchmeme!" unless ColorScheme === value
+        raise ArgumentError, "Silly! That's not a ColorSchmeme!" unless value.is_a?(ColorScheme)
         @color_schemes[name.to_s] = value
       end
 

data/lib/logging/diagnostic_context.rb

@@ -110,7 +110,7 @@ module Logging
     # Returns nil or the Hash removed from the stack.
     #
     def pop
-      return unless Thread.current[STACK_NAME]
+      return unless Thread.current.thread_variable_get(STACK_NAME)
       return unless stack.length > 1
       clear_context
       stack.pop
@@ -125,7 +125,7 @@ module Logging
     #
     def clear
       clear_context
-      Thread.current[STACK_NAME] = nil
+      Thread.current.thread_variable_set(STACK_NAME, nil)
       self
     end
 
@@ -140,15 +140,14 @@ module Logging
     def inherit( obj )
       case obj
       when Hash
-        Thread.current[STACK_NAME] = [obj.dup]
+        Thread.current.thread_variable_set(STACK_NAME, [obj.dup])
       when Thread
         return if Thread.current == obj
-        Thread.exclusive {
-          if obj[STACK_NAME]
-            hash = flatten(obj[STACK_NAME])
-            Thread.current[STACK_NAME] = [hash]
+        DIAGNOSTIC_MUTEX.synchronize do
+          if hash = obj.thread_variable_get(STACK_NAME)
+            Thread.current.thread_variable_set(STACK_NAME, [flatten(hash)])
           end
-        }
+        end
       end
 
       self
@@ -159,12 +158,18 @@ module Logging
     # application.
     #
     def context
-      c = Thread.current[NAME]
-      return c unless c.nil?
+      c = Thread.current.thread_variable_get(NAME)
 
-      return Thread.current[NAME] = {} unless Thread.current[STACK_NAME]
+      if c.nil?
+        c = if Thread.current.thread_variable_get(STACK_NAME)
+          flatten(stack)
+        else
+          Hash.new
+        end
+        Thread.current.thread_variable_set(NAME, c)
+      end
 
-      Thread.current[NAME] = flatten(stack)
+      return c
     end
 
     # Returns the stack of Hash objects that are storing the diagnostic
@@ -172,7 +177,12 @@ module Logging
     # one Hash.
     #
     def stack
-      Thread.current[STACK_NAME] ||= [{}]
+      s = Thread.current.thread_variable_get(STACK_NAME)
+      if s.nil?
+        s = [{}]
+        Thread.current.thread_variable_set(STACK_NAME, s)
+      end
+      return s
     end
 
     # Returns the most current Hash from the stack of contexts.
@@ -184,7 +194,7 @@ module Logging
     # Remove the flattened context.
     #
     def clear_context
-      Thread.current[NAME] = nil
+      Thread.current.thread_variable_set(NAME, nil)
       self
     end
 
@@ -199,7 +209,7 @@ module Logging
     # Raises an ArgumentError if hash is not a Hash.
     #
     def sanitize( hash, target = {} )
-      unless Hash === hash
+      unless hash.is_a?(Hash)
         raise ArgumentError, "Expecting a Hash but received a #{hash.class.name}"
       end
 
@@ -320,7 +330,7 @@ module Logging
     # Returns the NestedDiagnosticContext.
     #
     def clear
-      Thread.current[NAME] = nil
+      Thread.current.thread_variable_set(NAME, nil)
       self
     end
 
@@ -335,12 +345,12 @@ module Logging
     def inherit( obj )
       case obj
       when Array
-        Thread.current[NAME] = obj.dup
+        Thread.current.thread_variable_set(NAME, obj.dup)
       when Thread
         return if Thread.current == obj
-        Thread.exclusive {
-          Thread.current[NAME] = obj[NAME].dup if obj[NAME]
-        }
+        DIAGNOSTIC_MUTEX.synchronize do
+          Thread.current.thread_variable_set(NAME, obj.thread_variable_get(NAME).dup) if obj.thread_variable_get(NAME)
+        end
       end
 
       self
@@ -351,7 +361,12 @@ module Logging
     # running in the application.
     #
     def context
-      Thread.current[NAME] ||= Array.new
+      c = Thread.current.thread_variable_get(NAME)
+      if c.nil?
+        c = Array.new
+        Thread.current.thread_variable_set(NAME, c)
+      end
+      return c
     end
   end  # NestedDiagnosticContext
 
@@ -381,13 +396,13 @@ module Logging
   #
   def self.clear_diagnostic_contexts( all = false )
     if all
-      Thread.exclusive {
-        Thread.list.each { |thread|
-          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]
-        }
-      }
+      DIAGNOSTIC_MUTEX.synchronize do
+        Thread.list.each do |t|
+          t.thread_variable_set(MappedDiagnosticContext::NAME, nil)       if t.thread_variable?(MappedDiagnosticContext::NAME)
+          t.thread_variable_set(NestedDiagnosticContext::NAME, nil)       if t.thread_variable?(NestedDiagnosticContext::NAME)
+          t.thread_variable_set(MappedDiagnosticContext::STACK_NAME, nil) if t.thread_variable?(MappedDiagnosticContext::STACK_NAME)
+        end
+      end
     else
       MappedDiagnosticContext.clear
       NestedDiagnosticContext.clear
@@ -396,60 +411,72 @@ module Logging
     self
   end
 
-end  # module Logging
-
+  DIAGNOSTIC_MUTEX = Mutex.new
+end
 
 # :stopdoc:
-class Thread
-  class << self
-
-    %w[new start fork].each do |m|
-      class_eval <<-__, __FILE__, __LINE__
-        alias_method :_orig_#{m}, :#{m}
-        private :_orig_#{m}
-        def #{m}( *a, &b )
-          create_with_logging_context(:_orig_#{m}, *a ,&b)
-        end
-      __
-    end
-
-  private
+Logging::INHERIT_CONTEXT =
+  if ENV.key?("LOGGING_INHERIT_CONTEXT")
+    case ENV["LOGGING_INHERIT_CONTEXT"].downcase
+    when 'false', 'no', '0'; false
+    when false, nil; false
+    else true end
+  else
+    true
+  end
 
-    # In order for the diagnostic contexts to behave properly we need to
-    # inherit state from the parent thread. The only way I have found to do
-    # this in Ruby is to override `new` and capture the contexts from the
-    # parent Thread at the time the child Thread is created. The code below does
-    # just this. If there is a more idiomatic way of accomplishing this in Ruby,
-    # please let me know!
-    #
-    # Also, great care is taken in this code to ensure that a reference to the
-    # parent thread does not exist in the binding associated with the block
-    # being executed in the child thread. The same is true for the parent
-    # thread's mdc and ndc. If any of those references end up in the binding,
-    # then they cannot be garbage collected until the child thread exits.
-    #
-    def create_with_logging_context( m, *a, &b )
-      mdc, ndc = nil
+if Logging::INHERIT_CONTEXT
+  class Thread
+    class << self
 
-      if Thread.current[Logging::MappedDiagnosticContext::STACK_NAME]
-        mdc = Logging::MappedDiagnosticContext.context.dup
+      %w[new start fork].each do |m|
+        class_eval <<-__, __FILE__, __LINE__
+          alias_method :_orig_#{m}, :#{m}
+          private :_orig_#{m}
+          def #{m}( *a, &b )
+            create_with_logging_context(:_orig_#{m}, *a ,&b)
+          end
+        __
       end
 
-      if Thread.current[Logging::NestedDiagnosticContext::NAME]
-        ndc = Logging::NestedDiagnosticContext.context.dup
+    private
+
+      # In order for the diagnostic contexts to behave properly we need to
+      # inherit state from the parent thread. The only way I have found to do
+      # this in Ruby is to override `new` and capture the contexts from the
+      # parent Thread at the time the child Thread is created. The code below does
+      # just this. If there is a more idiomatic way of accomplishing this in Ruby,
+      # please let me know!
+      #
+      # Also, great care is taken in this code to ensure that a reference to the
+      # parent thread does not exist in the binding associated with the block
+      # being executed in the child thread. The same is true for the parent
+      # thread's mdc and ndc. If any of those references end up in the binding,
+      # then they cannot be garbage collected until the child thread exits.
+      #
+      def create_with_logging_context( m, *a, &b )
+        mdc, ndc = nil
+
+        if Thread.current.thread_variable_get(Logging::MappedDiagnosticContext::STACK_NAME)
+          mdc = Logging::MappedDiagnosticContext.context.dup
+        end
+
+        if Thread.current.thread_variable_get(Logging::NestedDiagnosticContext::NAME)
+          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)
+          b.call(*args)
+        }
       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)
-        b.call(*args)
-      }
     end
-
   end
-end  # Thread
+end
 # :startdoc:
 

data/lib/logging/layout.rb

@@ -41,13 +41,86 @@ class Layout
                   when :inspect, :yaml, :json; f
                   else :string end
 
-    b = opts.fetch(:backtrace, ::Logging.backtrace)
-    @backtrace = case b
-        when :on, 'on', true;    true
-        when :off, 'off', false; false
-        else
-          raise ArgumentError, "backtrace must be true or false"
-        end
+    self.backtrace   = opts.fetch(:backtrace,   ::Logging.backtrace)
+    self.utc_offset  = opts.fetch(:utc_offset,  ::Logging.utc_offset)
+    self.cause_depth = opts.fetch(:cause_depth, ::Logging.cause_depth)
+  end
+
+  # call-seq:
+  #    layout.backtrace = true
+  #
+  # Set the backtrace flag to the given value. This can be set to `true` or
+  # `false`.
+  #
+  def backtrace=( value )
+    @backtrace = case value
+      when :on, 'on', true;    true
+      when :off, 'off', false; false
+      else
+        raise ArgumentError, "backtrace must be `true` or `false`"
+      end
+  end
+
+  # Returns the backtrace setting.
+  attr_reader :backtrace
+  alias :backtrace? :backtrace
+
+  # Set the UTC offset used when formatting time values. If left unset, the
+  # default local time zone will be used for time values. This method accepts
+  # the `utc_offset` format supported by the `Time#localtime` method in Ruby.
+  #
+  # Passing "UTC" or `0` as the UTC offset will cause all times to be reported
+  # in the UTC timezone.
+  #
+  #   layout.utc_offset = "-07:00"  # Mountain Standard Time in North America
+  #   layout.utc_offset = "+01:00"  # Central European Time
+  #   layout.utc_offset = "UTC"     # UTC
+  #   layout.utc_offset = 0         # UTC
+  #
+  def utc_offset=( value )
+    @utc_offset = case value
+      when nil;             nil
+      when "UTC", "GMT", 0; 0
+      else
+        Time.now.localtime(value)
+        value
+      end
+  end
+
+  # Returns the UTC offset.
+  attr_reader :utc_offset
+
+  #
+  #
+  def cause_depth=( value )
+    if value.nil?
+      @cause_depth = ::Logging::DEFAULT_CAUSE_DEPTH
+    else
+      value = Integer(value)
+      @cause_depth = value < 0 ? ::Logging::DEFAULT_CAUSE_DEPTH : value
+    end
+  end
+
+  # Returns the exception cause depth formatting limit.
+  attr_reader :cause_depth
+
+  # Internal: Helper method that applies the UTC offset to the given `time`
+  # instance. A new Time is returned that is equivalent to the original `time`
+  # but pinned to the timezone given by the UTC offset.
+  #
+  # If a UTC offset has not been set, then the original `time` instance is
+  # returned unchanged.
+  #
+  def apply_utc_offset( time )
+    return time if utc_offset.nil?
+
+    time = time.dup
+    if utc_offset == 0
+      time.utc
+    else
+      time.localtime(utc_offset)
+    end
+    time
   end
 
   # call-seq:
@@ -84,11 +157,10 @@ class Layout
     case obj
     when String; obj
     when Exception
-      str = "<#{obj.class.name}> #{obj.message}"
-      if @backtrace && !obj.backtrace.nil?
-        str << "\n\t" << obj.backtrace.join("\n\t")
-      end
-      str
+      lines = ["<#{obj.class.name}> #{obj.message}"]
+      lines.concat(obj.backtrace) if backtrace? && obj.backtrace
+      format_cause(obj, lines)
+      lines.join("\n\t")
     when nil; "<#{obj.class.name}> nil"
     else
       str = "<#{obj.class.name}> "
@@ -101,6 +173,64 @@ class Layout
     end
   end
 
+  # Internal: Format any nested exceptions found in the given exception `e`
+  # while respecting the maximum `cause_depth`. The lines array is used to
+  # capture all the output lines form the nested exceptions; the array is later
+  # joined by the `format_obj` method.
+  #
+  # e     - Exception to format
+  # lines - Array of output lines
+  #
+  # Returns the input `lines` Array
+  def format_cause(e, lines)
+    return lines if cause_depth == 0
+
+    cause_depth.times do
+      break unless e.respond_to?(:cause) && e.cause
+
+      cause = e.cause
+      lines << "--- Caused by ---"
+      lines << "<#{cause.class.name}> #{cause.message}"
+      lines.concat(format_cause_backtrace(e, cause)) if backtrace? && cause.backtrace
+
+      e = cause
+    end
+
+    if e.respond_to?(:cause) && e.cause
+      lines << "--- Further #cause backtraces were omitted ---"
+    end
+
+    lines
+  end
+
+  # Internal: Format the backtrace of the nested `cause` but remove the common
+  # exception lines from the parent exception. This helps keep the backtraces a
+  # wee bit shorter and more comprehensible.
+  #
+  # e     - parent exception
+  # cause - the nested exception generating the returned backtrace
+  #
+  # Returns an Array of backtracke lines.
+  def format_cause_backtrace(e, cause)
+    # Find where the cause's backtrace differs from the parent exception's.
+    backtrace       = Array(e.backtrace)
+    cause_backtrace = Array(cause.backtrace)
+    index = -1
+    min_index = [backtrace.size, cause_backtrace.size].min * -1
+    just_in_case = -5000
+
+    while index > min_index && backtrace[index] == cause_backtrace[index] && index >= just_in_case
+      index -= 1
+    end
+
+    # Add on a few common frames to make it clear where the backtraces line up.
+    index += 3
+    index = -1 if index >= 0
+
+    cause_backtrace[0..index]
+  end
+
+
   # Attempt to format the _obj_ using yaml, but fall back to inspect style
   # formatting if yaml fails.
   #
@@ -126,7 +256,5 @@ class Layout
   rescue StandardError
     obj.inspect
   end
-
-end  # class Layout
-end  # module Logging
-
+end
+end