class_docstr: A Context that captures RunMetadata and performs profiling.
  
  ```python
    # Trace steps 100~200, profile at [150, 200] and dump profile at 200.
    with profile_context.ProfileContext('/tmp/train_dir',
                                        trace_steps=range(100, 200, 3),
                                        dump_steps=[200]) as pctx:
      opts = tf.profiler.ProfileOptionBuilder.time_and_memory()
      pctx.add_auto_profiling('op', opts, [150, 200])
      train_loop().
  
    # Tracing only.
    with profile_context.tfprof.ProfileContext('/tmp/train_dir') as pctx:
      # Run train/eval loop for at least few hundred steps. Profiles will be
      # dumped to train_dir. Use web UI or command line to do profiling.
      train_loop().
  
    # When session object is available, do explicit trace, profile and dump.
    with profile_context.ProfileContext('/tmp/train_dir',
                                        trace_steps=[],
                                        dump_steps=[]) as pctx:
      opts = tf.profiler.ProfileOptionBuilder.time_and_memory()
      pctx.trace_next_step()
      _ = session.run(train_op)
      pctx.profiler.profile_operations(options=opts)
  ```
  
  Args:
    profile_dir: Directory to store profiles.
    trace_steps: A list of session run steps to trace. If None, use
        pre-defined steps.
    dump_steps: A list of steps to dump the profile to `profile_dir`. If None,
        use pre-defined steps.
    enabled: If false, everything is disabled with minimal overhead. It allows
        user to only enable profiling when needed.
    debug: If true, also dumps the raw trace RunMetadata text file to
        profile_dir. And print debugging message. Useful for bug report.
docstr: Whether should do tracing at current step.
docstr_tok: ["Whether","should","do","tracing","at","current","step","."]
code: def _should_trace(self, step, graph, fetches):
      """Whether should do tracing at current step."""
      if self._traced_steps > MAX_TRACED_STEPS:
          return False
      # Check user-set tracing steps.
      if step in self._trace_steps or self._trace_next_step:
          self._traced_steps += 1
          return True
  
      # If no user-set tracing steps set and passes warm up steps, auto trace.
      if self._auto_tracing and step > WARMUP_STEPS:
          # If the fetches have not been seen before, trace it.
          with graph.as_default():
              fetch_names = [
                  f.name
                  for f in session._FetchMapper.for_fetch(
                      fetches
                  ).unique_fetches()
              ]  # pylint: disable=protected-access
          fetch_name = "-".join(sorted(fetch_names))
          if self._debug:
              sys.stderr.write(
                  "debug: trace fetches: %s\n" % fetch_name
              )
          if fetch_name not in self._fetched:
              self._fetched.add(fetch_name)
              self._traced_steps += 1
              return True
          # If the trace coverage is low, does some random tracing.
          if (
              self.profiler._coverage < 0.5
              and step < MAX_TRACED_STEPS
              and self._rng.randint(  # pylint: disable=protected-access
                  0, 10
              )
              < 2
          ):
              self._traced_steps += 1
              return True
      return False
  
imports: import contextlib
  import os
  import random
  import sys
  import threading
  from tensorflow.core.protobuf import config_pb2
  from tensorflow.python.client import session
  from tensorflow.python.framework import errors
  from tensorflow.python.framework import ops
  from tensorflow.python.platform import gfile
  from tensorflow.python.profiler import model_analyzer
  from tensorflow.python.util import _pywrap_tfprof
  from tensorflow.python.util import compat
label_desc: Use image node_id 8 for calling the ProfileContext obj's underlying member method code with example usage: obj._should_trace(step, graph, fetches) and returns: False, False, True, True, True