docs: def _pre_call(atdepth, parent, fqdn, stackdepth, *argl, **argd):
      """Checks whether the logging should create an entry based on stackdepth. If
      so, the entry is created.
      """
      from time import time
      if not atdepth:
          rstack = _reduced_stack()
          if "<module>" in rstack[-1]: # pragma: no cover
              code = rstack[-1][1]
          else:
              code = ""
  
          reduced = len(rstack)
          if msg.will_print(3): # pragma: no cover
              sstack = [' | '.join(map(str, r)) for r in rstack]
              msg.info("{} => stack ({}): {}".format(fqdn, len(rstack),
                                               ', '.join(sstack)), 3)
      else:
          reduced = stackdepth + 10
  
      bound = False
      if reduced <= stackdepth:
          args = _check_args(*argl, **argd)
          # At this point, we should start the entry. If the method raises an
          # exception, we should keep track of that. If this is an instance
          # method, we should get its UUID, if not, then we can just store the
          # entry under the full method name.
  
          #There is yet another subtletly here: many packages have a base, static
          #method that gets set as an instance method for sub-classes of a certain
          #ABC. In that case, parent will be a super-class of the first argument,
          #though the types will *not* be identical. Check for overlap in the base
          #classes of the first argument. It would be nice if we could easily
          #check for bound methods using inspect, but it doesn't work for some of
          #the C-extension modules...
          if (len(argl) > 0 and parent is not None and inspect.isclass(parent)):
              ftype = type(argl[0])
              if isinstance(argl[0], parent):
                  bound = True
              elif (inspect.isclass(ftype) and hasattr(ftype, "__bases__") and
                  inspect.isclass(parent) and hasattr(parent, "__bases__")): # pragma: no cover
                  common = set(ftype.__bases__) & set(parent.__bases__)
                  bound = len(common) > 0
                  
          if not bound:
              #For now, we use the fqdn; later, if the result is not None, we
              #will rather index this entry by the returned result, since we
              #can also access the fqdn in the entry details.
              ekey = fqdn
          else:
              # It must have the first argument be the instance.
              ekey = _tracker_str(argl[0])
  
          #Check whether the logging has been overidden by a configuration option.
          if (fqdn not in _logging or _logging[fqdn]):
              entry = {
                  "m": fqdn,
                  "a": args,
                  "s": time(),
                  "r": None,
                  "c": code,
              }
          else:
              entry = None
      else:
          entry = None
          atdepth = True
          ekey = None
  
      return (entry, atdepth, reduced, bound, ekey)