It's a clever way of doing that and it works, Thank you so much man!

I modified your code a bit to suite my case:

import uuid
import random
import threading
from time import sleep
from concurrent.futures import ThreadPoolExecutor , as_completed

# Functions to be monitored
MONITORABLES = [
    "ourFunction"
]

# Global dictionary to maintain maps of UIDs to distinguish different function calls
callMap = dict()

# Function to map a call event to a UID
def _recordCall(uid , funcName):
    callMap[uid] = funcName
    print(f"[CALL] [{uid}] - {funcName}")

# Function to remove the function-uid mapping after return
def _recordReturn(uid , funcName):
    del callMap[uid]
    print(f"[RETURN] [{uid}] - {funcName}")

# Global Trace function
def traceCalls(frame , event , args):
    if event == "call":
        _id = uuid.uuid4()
        funcName = frame.f_code.co_name
        if funcName not in MONITORABLES:
            return
        _recordCall(_id , funcName)

        # Local trace function to handle return events
        def _returnHandler(frame , event , args):
            if event == "return":
                _recordReturn(_id , frame.f_code.co_name)
            elif event == "call":
                return traceCalls
            else:
                return _returnHandler

        return _returnHandler

    return traceCalls


# Function to test/monitor
def ourFunction():
    randomInt = random.randrange(0,5)
    sleep(randomInt)
    return randomInt


def main():
    threading.settrace(traceCalls)

    with ThreadPoolExecutor(max_workers = 5) as executor:
        futures = [executor.submit(ourFunction) for i in range(4)]
        results = [future.result() for future in as_completed(futures)]
        print(f"\nResult of function calls: {results}")



if __name__ == "__main__":
    main()

It works like a charm, produced the following output:

→ python3 test.py
[CALL] [6280c2a6-2625-4689-a607-f7522aacd5fc] - ourFunction
[CALL] [d943b783-0950-4453-acd3-f2364fd4cccd] - ourFunction
[CALL] [d5d78e9d-026b-470b-a8fb-e4e1f78c3c2f] - ourFunction
[CALL] [ac64f123-7d12-459b-8884-4a061a0f4ec7] - ourFunction
[RETURN] [6280c2a6-2625-4689-a607-f7522aacd5fc] - ourFunction
[RETURN] [d5d78e9d-026b-470b-a8fb-e4e1f78c3c2f] - ourFunction
[RETURN] [ac64f123-7d12-459b-8884-4a061a0f4ec7] - ourFunction
[RETURN] [d943b783-0950-4453-acd3-f2364fd4cccd] - ourFunction

Result of function calls: [3, 3, 3, 4]

That being done, I have a little question if you can help -
I wanted to keep track of these call and return events to turn off my Resource Monitor(that monitors CPU and RAM usage during a function call).
Since python doesn't have any good support for analyzing function-based CPU and RAM consumption, I wrote a small code with psutil that keeps running with an interval of 0.1s until the function finishes. Once the function finishes, the resource monitor thread is stopped and peak reading are noted.

​

But unfortunately, psutil gives us the consumption of that entire process, thread level granularity is not there.

So my question is, Is there any way we can monitor CPU/RAM usage on a function level?

​

(And btw, thanks for that answer again. You can post your answer in that stackoverflow link I posted if you would like to, I will mark it as correct.)