Checks whether the logging should create an entry based on stackdepth. If
    so, the entry is created.

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)