Usamos uma biblioteca fornecida por outra equipe interna. (A analogia instável começa agora)

from externalTeam import dataCreator
datacreator.createPizza()
datacreator.createBurger()
datacreator.createHotDog()

Recentemente, descobrimos que um único método deles estava demorando mais de um minuto para ser executado em determinadas situações. Para depurar isso, tive que entrar em nosso código e adicionar tempos limite em todas as chamadas desse métod

import time
from externalTeam import dataCreator
start = time.clock()
datacreator.createPizza()
stop = time.clock()
print "It took %s seconds to perform createPizza" % (str(stop-start))

Em retrospecto, é porque estamos chamando createPizza em todo o lugar e não controlamos o createPizza (a analogia está começando a se deteriorar um pouco aqui). Prefiro chamar createPizza em um só lugar e poder adicionar um cronômetro. Meu primeiro pensamento para conseguir isso seria criar um wrap todos os seus métodos na minha própria classe de wrapper. Esse é o oposto de DRY, e sempre que eles adicionam outro método, eu tenho que atualizar nossa biblioteca para incluir isso também:

import time
from externalTeam import dataCreator
def createPizza(self):
    start = time.clock()
    datacreator.createPizza()
    stop = time.clock()
    print "It took %s seconds to perform createPizza" % (str(stop-start))

def createBurger(self):
    start = time.clock()
    datacreator.createPizza()
    stop = time.clock()
    print "It took %s seconds to perform createBurger" % (str(stop-start))

def createHotDog(self):
    start = time.clock()
    datacreator.createPizza()
    stop = time.clock()
    print "It took %s seconds to perform createHotDog" % (str(stop-start))    

O que eu quero é uma maneira de sempre executar algumas linhas de código em torno de cada função que está sendo chamada de dataCreator. Deve haver alguma maneira de fazer isso por meio de uma classe intermediária cujos métodos podem ser definidos dinamicamente - ou melhor, deixados indefinidos, certo?