logging 2.1.0 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e350554eb562c0d216fa262c015afb4c2a68b82e
-  data.tar.gz: 22820d111096e8c44e7d0908e1cb7cca27d49009
+  metadata.gz: ee30a5922d46012d8fc4e14db5cc86ea7dce9c6a
+  data.tar.gz: 7183a4f01f0dd1000ab86d05c8b40e605dbb4b10
 SHA512:
-  metadata.gz: d8167665ad0871c41f053154f7d36686afd08d15d151a3d8c759a20ab9d845060494ed580fe6c95eeddccea69c57a6d94d464f6f3c463ed126b61c8021d05ac9
-  data.tar.gz: e741f1bea9ca11f52a06ca5b2873007430f26b02d92262222b2e64a86ae0de9635c2482b57e40c0b512d6a180486d665b9e36196a39d418311437a855e0d5a7c
+  metadata.gz: 377702172ae965d27c082acd60914e0f3420a0e0bdfc5d981ac3cfad7c8f3bf46095007511075b6a9db9225963911967d3d63989a3ee6dc42588269092796a72
+  data.tar.gz: 1a6f33f20259879ca8cc9adcbd9a3bfb14c44f03a15311711f11ff4bf98edfd9821000e8b9afcb5401080a693e391bb83e56bd0055e1eedcbba6ce7ba4a92f2b

data/.travis.yml

@@ -6,9 +6,9 @@ install:        "rake gem:install_dependencies"
 script: "rake"
 
 rvm:
-  - 1.9.3
-  - 2.0.0
-  - 2.1.5
-  - 2.2.1
-  - 2.3.0
-  - jruby-9.0.4.0
+  - 2.0.0-p648
+  - 2.1.10
+  - 2.2.6
+  - 2.3.3
+  - 2.4.0
+  - jruby-9.1.8.0

data/History.txt

@@ -1,3 +1,18 @@
+== 2.2.0 / 2017-03-09
+
+Enhancements
+- diagnostic context inheritance is now optional [PR #160]
+- add support for setting a UTC offset [PR #157]
+- setting a basepath for call tracing [PR #154]
+
+Bug Fixes
+- use thread-local variables for diagnostic contexts [PR #162]
+- replace `Fixnum` with `Integer` [PR #161]
+- fixed a race condition in the rolling file appender [PR #151]
+
+Deprecations
+- dropped Ruby 1.9 support
+
 == 2.1.0 / 2016-03-13
 
 Enhancements

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License
+
+Copyright (c) 2007-2016 Tim Pease
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -1,12 +1,12 @@
 ## Logging
-by Tim Pease [![](https://secure.travis-ci.org/TwP/logging.png)](https://travis-ci.org/TwP/logging)
+by Tim Pease [![](https://secure.travis-ci.org/TwP/logging.svg)](https://travis-ci.org/TwP/logging)
 
 * [Homepage](http://rubygems.org/gems/logging)
 * [Github Project](https://github.com/TwP/logging)
 
 ### Description
 
-Logging is a flexible logging library for use in Ruby programs based on the
+**Logging** is a flexible logging library for use in Ruby programs based on the
 design of Java's log4j library. It features a hierarchical logging system,
 custom level names, multiple output destinations per log event, custom
 formatting, and more.
@@ -82,23 +82,23 @@ class SecondClass
 end
 ```
 
-There are many more examples in the [examples folder](https://github.com/TwP/logging/tree/master/examples)
-of the logging package. The recommended reading order is the following:
-
-* [simple.rb](https://github.com/TwP/logging/blob/master/examples/simple.rb)
-* [rspec_integration.rb](https://github.com/TwP/logging/blob/master/examples/rspec_integration.rb)
-* [loggers.rb](https://github.com/TwP/logging/blob/master/examples/loggers.rb)
-* [classes.rb](https://github.com/TwP/logging/blob/master/examples/classes.rb)
-* [hierarchies.rb](https://github.com/TwP/logging/blob/master/examples/hierarchies.rb)
-* [names.rb](https://github.com/TwP/logging/blob/master/examples/names.rb)
-* [lazy.rb](https://github.com/TwP/logging/blob/master/examples/lazy.rb)
-* [appenders.rb](https://github.com/TwP/logging/blob/master/examples/appenders.rb)
-* [layouts.rb](https://github.com/TwP/logging/blob/master/examples/layouts.rb)
-* [formatting.rb](https://github.com/TwP/logging/blob/master/examples/formatting.rb)
-* [colorization.rb](https://github.com/TwP/logging/blob/master/examples/colorization.rb)
-* [consolidation.rb](https://github.com/TwP/logging/blob/master/examples/consolidation.rb)
-* [fork.rb](https://github.com/TwP/logging/blob/master/examples/fork.rb)
-* [mdc.rb](https://github.com/TwP/logging/blob/master/examples/mdc.rb)
+There are many more examples in the [examples folder](/examples) of the logging
+package. The recommended reading order is the following:
+
+* [simple.rb](/examples/simple.rb)
+* [rspec_integration.rb](/examples/rspec_integration.rb)
+* [loggers.rb](/examples/loggers.rb)
+* [classes.rb](/examples/classes.rb)
+* [hierarchies.rb](/examples/hierarchies.rb)
+* [names.rb](/examples/names.rb)
+* [lazy.rb](/examples/lazy.rb)
+* [appenders.rb](/examples/appenders.rb)
+* [layouts.rb](/examples/layouts.rb)
+* [reusing_layouts.rb](/examples/reusing_layouts.rb)
+* [formatting.rb](/examples/formatting.rb)
+* [colorization.rb](/examples/colorization.rb)
+* [fork.rb](/examples/fork.rb)
+* [mdc.rb](/examples/mdc.rb)
 
 ### Extending
 
@@ -135,25 +135,4 @@ After this is done you can rake `rake -T` to see the available rake tasks.
 
 ### License
 
-The MIT License
-
-Copyright (c) 2015 Tim Pease
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-'Software'), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+The MIT License - see the [LICENSE](/LICENSE) file for the full text.

data/examples/layouts.rb

@@ -33,7 +33,7 @@
   log.level = :debug
 
   log.debug "a very nice little debug message"
-  log.info "things are operating nominally"
+  log.info "things are operating normally"
   log.warn "this is your last warning"
   log.error StandardError.new("something went horribly wrong")
   log.fatal "I Die!"

data/examples/lazy.rb

@@ -2,7 +2,7 @@
 #
 # It happens sometimes that it is very expensive to construct a logging
 # message; for example, if a large object structure has to be traversed
-# during executing of an `object.to_s` method. It would be convenient to
+# during execution of an `object.to_s` method. It would be convenient to
 # delay creation of the message until the log event actually takes place.
 #
 # For example, with a logger configured only to show WARN messages and higher,

data/examples/reusing_layouts.rb

@@ -0,0 +1,51 @@
+# :stopdoc:
+#
+# The formatting of log messages is controlled by the layout given to the
+# appender. By default all appenders use the Basic layout. It's pretty
+# basic. However, a more sophisticated Pattern layout can be used or one of
+# the Parseable layouts -- JSON or YAML.
+#
+# The available layouts are:
+#
+#   Logging.layouts.basic
+#   Logging.layouts.pattern
+#   Logging.layouts.json
+#   Logging.layouts.yaml
+#
+# After you configure a layout, you can reuse that layout among different
+# appenders if you so choose. This enables you to have some the style of log
+# output being sent to multiple destinations.
+#
+# We will store a Layout instance in a local variable, and then pass that
+# instance to each appender.
+#
+
+  require 'logging'
+
+  # create our pattern layout instance
+  layout = Logging.layouts.pattern \
+    :pattern      => '[%d] %-5l %c: %m\n',
+    :date_pattern => '%Y-%m-%d %H:%M:%S'
+
+  # only show "info" or higher messages on STDOUT using our layout
+  Logging.appenders.stdout \
+    :level  => :info,
+    :layout => layout
+
+  # send all log events to the development log (including debug) using our layout
+  Logging.appenders.rolling_file \
+    'development.log',
+    :age    => 'daily',
+    :layout => layout
+
+  log = Logging.logger['Foo::Bar']
+  log.add_appenders 'stdout', 'development.log'
+  log.level = :debug
+
+  log.debug "a very nice little debug message"
+  log.info "things are operating normally"
+  log.warn "this is your last warning"
+  log.error StandardError.new("something went horribly wrong")
+  log.fatal "I Die!"
+
+# :startdoc:

data/lib/logging.rb

@@ -95,9 +95,9 @@ module Logging
       layout = ::Logging::Layouts::Pattern.new(l_opts)
 
       a_opts = Hash.new
-      a_opts[:size] = size if size.instance_of?(Fixnum)
+      a_opts[:size] = size if size.is_a?(Integer)
       a_opts[:age]  = age  if age.instance_of?(String)
-      a_opts[:keep] = keep if keep.instance_of?(Fixnum)
+      a_opts[:keep] = keep if keep.is_a?(Integer)
       a_opts[:filename] = dev if dev.instance_of?(String)
       a_opts[:layout] = layout
       a_opts.merge! opts
@@ -311,6 +311,53 @@ module Logging
           end
     end
 
+    # Set the default UTC offset used when formatting time values sent to the
+    # appenders. 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.
+    #
+    #   Logging.utc_offset = "-07:00"  # Mountain Standard Time in North America
+    #   Logging.utc_offset = "+01:00"  # Central European Time
+    #   Logging.utc_offset = "UTC"     # UTC
+    #   Logging.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
+
+    attr_reader :utc_offset
+
+    # Used to define a `basepath` that will be removed from filenames when
+    # reporting tracing information for log events. Normally you would set this
+    # to the root of your project:
+    #
+    #   Logging.basepath = "/home/user/nifty_project"
+    #
+    # Or if you are in a Rails environment:
+    #
+    #   Logging.basepath = Rails.root.to_s
+    #
+    # The basepath is expanded to a full path with trailing slashes removed.
+    # This setting will be cleared by a call to `Logging.reset`.
+    def basepath=( path )
+      if path.nil? || path.to_s.empty?
+        @basepath = nil
+      else
+        @basepath = File.expand_path(path)
+      end
+    end
+
+    attr_reader :basepath
+
     # Returns the library path for the module. If any arguments are given,
     # they will be joined to the end of the library path using
     # <tt>File.join</tt>.
@@ -405,7 +452,7 @@ module Logging
     # to false. It uses its own appender to send messages to stderr.
     #
     def show_configuration( io = STDOUT, logger = 'root', indent = 0 )
-      logger = ::Logging::Logger[logger] unless ::Logging::Logger === logger
+      logger = ::Logging::Logger[logger] unless logger.is_a?(::Logging::Logger)
 
       io << logger._dump_configuration(indent)
 
@@ -466,8 +513,10 @@ module Logging
       LEVELS.clear
       LNAMES.clear
       remove_instance_variable :@backtrace if defined? @backtrace
+      remove_instance_variable :@basepath  if defined? @basepath
       remove_const :MAX_LEVEL_LENGTH if const_defined? :MAX_LEVEL_LENGTH
       remove_const :OBJ_FORMAT if const_defined? :OBJ_FORMAT
+      self.utc_offset = nil
       self
     end
 

data/lib/logging/appender.rb

@@ -114,7 +114,7 @@ class Appender
   #
   # Set the level for this appender; log events below this level will be
   # ignored by this appender. The level can be either a +String+, a
-  # +Symbol+, or a +Fixnum+. An +ArgumentError+ is raised if this is not
+  # +Symbol+, or an +Integer+. An +ArgumentError+ is raised if this is not
   # the case.
   #
   # There are two special levels -- "all" and "off". The former will
@@ -138,7 +138,7 @@ class Appender
   def level=( level )
     lvl = case level
           when String, Symbol; ::Logging::level_num(level)
-          when Fixnum; level
+          when Integer; level
           when nil; 0
           else
             raise ArgumentError,

data/lib/logging/appenders/console.rb

@@ -24,7 +24,7 @@ module Logging::Appenders
       name = self.class.name.split("::").last.downcase
       io   = Object.const_get(name.upcase)
 
-      opts = Hash === args.last ? args.pop : {}
+      opts = args.last.is_a?(Hash) ? args.pop : {}
       name = args.shift unless args.empty?
 
       opts[:encoding] = io.external_encoding if io.respond_to? :external_encoding

data/lib/logging/appenders/rolling_file.rb

@@ -141,6 +141,15 @@ module Logging::Appenders
       @roller.copy_file
     end
 
+    # Returns the modification time of the copy file if one exists. Otherwise
+    # returns `nil`.
+    def copy_file_mtime
+      return nil unless ::File.exist?(copy_file)
+      ::File.mtime(copy_file)
+    rescue Errno::ENOENT
+      nil
+    end
+
     # Write the given _event_ to the log file. The log file will be rolled
     # if the maximum file size is exceeded or if the file is older than the
     # maximum age.
@@ -166,7 +175,8 @@ module Logging::Appenders
 
     # Returns +true+ if the log file needs to be rolled.
     def roll_required?
-      return false if ::File.exist?(copy_file) && (Time.now - ::File.mtime(copy_file)) < 180
+      mtime = copy_file_mtime
+      return false if mtime && (Time.now - mtime) < 180
 
       # check if max size has been exceeded
       s = @size ? ::File.size(filename) > @size : false

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
-        DIAGNOSTIC_MUTEX.synchronize {
-          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
-        DIAGNOSTIC_MUTEX.synchronize {
-          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
-      DIAGNOSTIC_MUTEX.synchronize {
-        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
@@ -397,61 +412,71 @@ module Logging
   end
 
   DIAGNOSTIC_MUTEX = Mutex.new
-
-end  # module Logging
-
+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
+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
 
-  private
+if Logging::INHERIT_CONTEXT
+  class Thread
+    class << self
 
-    # 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[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: