class_docstr: Helper to log a traceback upon destruction if not cleared.
  
  This solves a nasty problem with Futures and Tasks that have an
  exception set: if nobody asks for the exception, the exception is
  never logged.  This violates the Zen of Python: 'Errors should
  never pass silently.  Unless explicitly silenced.'
  
  However, we don't want to log the exception as soon as
  set_exception() is called: if the calling code is written
  properly, it will get the exception and handle it properly.  But
  we *do* want to log it if result() or exception() was never called
  -- otherwise developers waste a lot of time wondering why their
  buggy code fails silently.
  
  An earlier attempt added a __del__() method to the Future class
  itself, but this backfired because the presence of __del__()
  prevents garbage collection from breaking cycles.  A way out of
  this catch-22 is to avoid having a __del__() method on the Future
  class itself, but instead to have a reference to a helper object
  with a __del__() method that logs the traceback, where we ensure
  that the helper object doesn't participate in cycles, and only the
  Future has a reference to it.
  
  The helper object is added when set_exception() is called.  When
  the Future is collected, and the helper is present, the helper
  object is also collected, and its __del__() method will log the
  traceback.  When the Future's result() or exception() method is
  called (and a helper object is present), it removes the the helper
  object, after calling its clear() method to prevent it from
  logging.
  
  One downside is that we do a fair amount of work to extract the
  traceback from the exception, even when it is never logged.  It
  would seem cheaper to just store the exception object, but that
  references the traceback, which references stack frames, which may
  reference the Future, which references the _TracebackLogger, and
  then the _TracebackLogger would be included in a cycle, which is
  what we're trying to avoid!  As an optimization, we don't
  immediately format the exception; we only do the work when
  activate() is called, which call is delayed until after all the
  Future's callbacks have run.  Since usually a Future has at least
  one callback (typically set by 'yield From') and usually that
  callback extracts the callback, thereby removing the need to
  format the exception.
  
  PS. I don't claim credit for this solution.  I first heard of it
  in a discussion about closing files when they are collected.
code: def __del__(self, is_finalizing=is_finalizing):
      if not is_finalizing() and self.formatted_tb:
          app_log.error(
              "Future exception was never retrieved: %s",
              "".join(self.formatted_tb).rstrip(),
          )
  
imports: from __future__ import absolute_import, division, print_function
  import functools
  import platform
  import textwrap
  import traceback
  import sys
  from tornado.log import app_log
  from tornado.stack_context import ExceptionStackContext, wrap
  from tornado.util import raise_exc_info, ArgReplacer, is_finalizing
label_desc: Use image node_id 4 for calling the _TracebackLogger obj's underlying member method code with example usage: obj.__del__(is_finalizing) without return types