How to use the pex.tracer.TRACER function in pex

def execute_script(self, script_name):
    dists = list(self._activate())

    dist, entry_point = get_entry_point_from_console_script(script_name, dists)
    if entry_point:
      TRACER.log('Found console_script %r in %r' % (entry_point, dist))
      sys.exit(self.execute_entry(entry_point))

    dist_script = get_script_from_distributions(script_name, dists)
    if not dist_script:
      raise self.NotFound('Could not find script %r in pex!' % script_name)
    TRACER.log('Found script %r in %r' % (script_name, dist))
    return self.execute_content(dist_script.path, dist_script.read_contents(), argv0=script_name)

except ValueError:
    args, cmdline = args, []

  options, reqs = parser.parse_args(args=args)
  if options.pex_root:
    ENV.set('PEX_ROOT', options.pex_root)
  else:
    options.pex_root = ENV.PEX_ROOT  # If option not specified fallback to env variable.

  # Don't alter cache if it is disabled.
  if options.cache_dir:
    options.cache_dir = make_relative_to_root(options.cache_dir)
  options.interpreter_cache_dir = make_relative_to_root(options.interpreter_cache_dir)

  with ENV.patch(PEX_VERBOSE=str(options.verbosity)):
    with TRACER.timed('Building pex'):
      pex_builder = build_pex(reqs, options, resolver_options_builder)

    if options.pex_name is not None:
      log('Saving PEX file to %s' % options.pex_name, v=options.verbosity)
      tmp_name = options.pex_name + '~'
      safe_delete(tmp_name)
      pex_builder.build(tmp_name)
      os.rename(tmp_name, options.pex_name)
      return 0

    if options.platform != Platform.current():
      log('WARNING: attempting to run PEX with differing platform!')

    pex_builder.freeze()

    log('Running PEX file at %s with args %s' % (pex_builder.path(), cmdline), v=options.verbosity)

# Short-circuit if there is a local copy
  if os.path.exists(target_link) and os.path.exists(os.path.realpath(target_link)):
    egg = EggPackage(os.path.realpath(target_link))
    if egg.satisfies(requirement):
      return egg

  context = Context.get()
  iterator = Iterator(fetchers=fetchers, crawler=Crawler(context))
  links = [link for link in iterator.iter(requirement) if isinstance(link, SourcePackage)]

  with TRACER.timed('Interpreter cache resolving %s' % requirement, V=2):
    for link in links:
      with TRACER.timed('Fetching %s' % link, V=3):
        sdist = context.fetch(link)

      with TRACER.timed('Installing %s' % link, V=3):
        installer = installer_provider(sdist)
        dist_location = installer.bdist()
        target_location = os.path.join(
            os.path.dirname(target_link), os.path.basename(dist_location))
        shutil.move(dist_location, target_location)
        _safe_link(target_location, target_link)

      return EggPackage(target_location)

def _categorize_build_requests(self, build_requests, dist_root):
    unsatisfied_build_requests = []
    install_requests = []
    for build_request in build_requests:
      build_result = build_request.result(dist_root)
      if not build_result.is_built:
        TRACER.log('Building {} to {}'.format(build_request.source_path, build_result.dist_dir))
        unsatisfied_build_requests.append(build_request)
      else:
        TRACER.log('Using cached build of {} at {}'
                   .format(build_request.source_path, build_result.dist_dir))
        install_requests.extend(build_result.finalize_build())
    return unsatisfied_build_requests, install_requests

def _tracer():
  from pex.tracer import TRACER

  return TRACER

def crawl_link(cls, context, link):
    if link.local:
      return cls.crawl_local(link)
    elif link.remote:
      return cls.crawl_remote(context, link)
    else:
      TRACER.log('Failed to crawl %s: unknown scheme %s' % (link.url, link.scheme))
      return set(), set()

def run(self):
    if self._installed is not None:
      return self._installed

    with TRACER.timed('Installing %s' % self._install_tmp, V=2):
      env = self._interpreter.sanitized_environment()
      mixins = OrderedSet(['setuptools'] + self.mixins)
      env['PYTHONPATH'] = os.pathsep.join(third_party.expose(mixins))
      env['__PEX_UNVENDORED__'] = '1'

      command = [self._interpreter.binary, '-s', '-'] + self.setup_command()
      try:
        Executor.execute(command,
                         env=env,
                         cwd=self._source_dir,
                         stdin_payload=self.setup_py_wrapper.encode('ascii'))
        self._installed = True
      except Executor.NonZeroExit as e:
        self._installed = False
        name = os.path.basename(self._source_dir)
        print('**** Failed to install %s (caused by: %r\n):' % (name, e), file=sys.stderr)

def _activate(self):
    self.update_candidate_distributions(self.load_internal_cache(self._pex, self._pex_info))

    if not self._pex_info.zip_safe and os.path.isfile(self._pex):
      self.update_module_paths(self.force_local(self._pex, self._pex_info))

    all_reqs = [Requirement.parse(req) for req in self._pex_info.requirements]

    working_set = WorkingSet([])
    resolved = self._resolve(working_set, all_reqs)

    for dist in resolved:
      with TRACER.timed('Activating %s' % dist, V=2):
        working_set.add(dist)

        if os.path.isdir(dist.location):
          with TRACER.timed('Adding sitedir', V=2):
            if dist.location not in sys.path and self._inherit_path == "fallback":
              # Prepend location to sys.path.
              # This ensures that bundled versions of libraries will be used before system-installed
              # versions, in case something is installed in both, helping to favor hermeticity in
              # the case of non-hermetic PEX files (i.e. those with inherit_path=True).
              #
              # If the path is not already in sys.path, site.addsitedir will append (not prepend)
              # the path to sys.path. But if the path is already in sys.path, site.addsitedir will
              # leave sys.path unmodified, but will do everything else it would do. This is not part
              # of its advertised contract (which is very vague), but has been verified to be the
              # case by inspecting its source for both cpython 2.7 and cpython 3.7.
              sys.path.insert(0, dist.location)

self.update_candidate_distributions(self.load_internal_cache(self._pex, self._pex_info))

    if not self._pex_info.zip_safe and os.path.isfile(self._pex):
      self.update_module_paths(self.force_local(self._pex, self._pex_info))

    all_reqs = [Requirement.parse(req) for req in self._pex_info.requirements]

    working_set = WorkingSet([])
    resolved = self._resolve(working_set, all_reqs)

    for dist in resolved:
      with TRACER.timed('Activating %s' % dist, V=2):
        working_set.add(dist)

        if os.path.isdir(dist.location):
          with TRACER.timed('Adding sitedir', V=2):
            if dist.location not in sys.path and self._inherit_path == "fallback":
              # Prepend location to sys.path.
              # This ensures that bundled versions of libraries will be used before system-installed
              # versions, in case something is installed in both, helping to favor hermeticity in
              # the case of non-hermetic PEX files (i.e. those with inherit_path=True).
              #
              # If the path is not already in sys.path, site.addsitedir will append (not prepend)
              # the path to sys.path. But if the path is already in sys.path, site.addsitedir will
              # leave sys.path unmodified, but will do everything else it would do. This is not part
              # of its advertised contract (which is very vague), but has been verified to be the
              # case by inspecting its source for both cpython 2.7 and cpython 3.7.
              sys.path.insert(0, dist.location)
            site.addsitedir(dist.location)

        dist.activate()

requirers = unresolved_reqs.setdefault(e.req, OrderedSet())
          if e.requirers:
            requirers.update(reqs_by_key[requirer] for requirer in e.requirers)

    if unresolved_reqs:
      TRACER.log('Unresolved requirements:')
      for req in unresolved_reqs:
        TRACER.log('  - %s' % req)

      TRACER.log('Distributions contained within this pex:')
      distributions_by_key = defaultdict(list)
      if not self._pex_info.distributions:
        TRACER.log('  None')
      else:
        for dist_name, dist_digest in self._pex_info.distributions.items():
          TRACER.log('  - %s' % dist_name)
          distribution = DistributionHelper.distribution_from_path(
            path=os.path.join(self._pex_info.install_cache, dist_digest, dist_name)
          )
          distributions_by_key[distribution.as_requirement().key].append(distribution)

      if not self._pex_info.ignore_errors:
        items = []
        for index, (requirement, requirers) in enumerate(unresolved_reqs.items()):
          rendered_requirers = ''
          if requirers:
            rendered_requirers = (
              '\n    Required by:'
              '\n      {requirers}'
            ).format(requirers='\n      '.join(map(str, requirers)))

          items.append(