def apitrace_wrapper()

in src/hpc/autoscale/hpclogging.py [0:0]
61 lines of code
11 McCabe index (conditional complexity)

    def apitrace_wrapper(*args: Any, **kwargs: Any) -> Any:
        global __CALL_ID
        call_id = "invoke-{}".format(__CALL_ID)
        __CALL_ID += 1
        instance_id = "inst-{}".format(__INSTANCE_ID)

        sig = inspect.signature(function)
        arg_strs: List[str] = []
        param_names = list(sig.parameters.keys())
        self_arg = None
        args_dict = {}

        for n in range(len(args)):
            arg_name = param_names[min(n, len(param_names) - 1)]
            arg_value = args[n]
            args_dict[arg_name] = arg_value

            if arg_name == "self":
                if function.__name__ != "__init__":
                    self_arg = arg_value
                else:
                    self_arg = "__init__"
            else:
                arg_strs.append("{}={}".format(arg_name, repr(arg_value)))

        args_dict.update(kwargs)

        for arg_name, arg_value in kwargs.items():
            arg_strs.append("{}={}".format(arg_name, repr(arg_value)))

        if trace_level:
            trace(
                "TRACE_ENTER: [%s] [%s] %s invoke %s(%s)",
                instance_id,
                call_id,
                self_arg or "function",
                function.__name__,
                ", ".join(arg_strs),
            )

        if fine_level:
            fine(
                "ENTER: [%s] [%s] %s(%s)",
                instance_id,
                call_id,
                function.__name__,
                ", ".join(arg_strs),
            )

        ret_val = function(*args, **kwargs)
        if trace_level:
            trace(
                "TRACE_EXIT: [%s] [%s] %s(...) -> %s",
                instance_id,
                call_id,
                function.__name__,
                repr(ret_val),
            )

        if fine_level:
            fine(
                "EXIT: [%s] [%s] %s(...) -> %s",
                instance_id,
                call_id,
                function.__name__,
                repr(ret_val),
            )

        if repro_level:
            reprolog(function, args_dict, ret_val)

        return ret_val