Disons que nous exécutons une application Flask sur Gunicorn (parce que nous sommes cools comme ça). Nous avons quelques points de terminaison, et l'un d'eux pose problème. Il est temps de mettre nos lunettes py-spy et de voir ce qui se passe.

Notre Suspect : Le Gestionnaire Gourmand en CPU

Voici une application Flask simple avec un gestionnaire qui ne fait clairement pas de bien :


from flask import Flask
import time

app = Flask(__name__)

@app.route('/')
def hello_world():
    return 'Hello, World!'

@app.route('/cpu_hog')
def cpu_hog():
    # C'est ici que la magie (lire : le problème) se produit
    result = 0
    for i in range(10000000):
        result += i
    return f"J'ai compté jusqu'à {result}. N'êtes-vous pas fier ?"

if __name__ == '__main__':
    app.run()

Alerte spoiler : Ce point de terminaison /cpu_hog est notre principal suspect.

Entrez py-spy : Notre Accompagnateur de Profilage

Tout d'abord, ajoutons py-spy à notre équipe :


pip install py-spy

Maintenant, lançons notre serveur Gunicorn :


gunicorn app:app -w 4

Voici la partie amusante. Dans un autre terminal, lançons py-spy sur notre serveur WSGI sans méfiance :


sudo py-spy record -o profile.svg --pid $(pgrep -f gunicorn) --subprocesses
Conseil Pro : Nous utilisons sudo ici car py-spy doit s'attacher au processus. Soyez prudent avec les pouvoirs sudo. Avec un grand pouvoir vient... eh bien, vous connaissez la suite.

Décodage des Résultats de Profilage : CSI : Édition CPU

Après avoir frappé notre point de terminaison /cpu_hog quelques fois (allez-y, nous attendrons), regardons ce magnifique graphique en flamme SVG que py-spy a généré pour nous.

Flame Graph
Notre graphique de consommation CPU. C'est comme une scène de crime, mais pour le code.

Que voyons-nous ? Un véritable incendie de consommation CPU dans notre fonction cpu_hog ! C'est comme repérer Charlie, si Charlie était un goulet d'étranglement de performance portant une chemise rayée d'inefficacité.

Décomposition du Graphique en Flamme

  • La largeur de chaque barre représente le temps passé dans cette fonction
  • Les couleurs ? Elles sont juste jolies. Ne lisez pas trop dedans.
  • Les barres empilées montrent la pile d'appels. C'est comme un sandwich de lenteur.

L'Intrigue S'épaissit : Analyser Nos Découvertes

Alors, qu'avons-nous appris de notre aventure py-spy ?

  1. Notre fonction cpu_hog porte bien son nom. Elle monopolise le CPU comme si c'était démodé.
  2. Le coupable ? Cette boucle for qui a l'air innocente. Elle fait plus d'itérations qu'une machine à laver bloquée en mode essorage.
  3. Nos autres points de terminaison (comme hello_world) sont à peine visibles. Ce sont les héros méconnus de notre application.

Coup de Théâtre : Optimiser Notre CPU Hog

Maintenant que nous avons pris notre coupable de performance en flagrant délit, réformons-le :


@app.route('/cpu_hog_reformed')
def cpu_hog_reformed():
    # Utilisons une méthode plus efficace pour additionner les nombres
    result = sum(range(10000001))
    return f"J'ai compté efficacement jusqu'à {result}. Bien mieux, non ?"

Lancez à nouveau py-spy avec ce nouveau point de terminaison, et voilà ! Notre graphique en flamme devrait ressembler moins à un incendie et plus à un feu de camp confortable.

Leçons Apprises : Le Guide de Profilage Py-spy

Quelles perles de sagesse pouvons-nous tirer de cette escapade de profilage ?

  • Faites confiance, mais vérifiez : Même un code qui semble simple peut être un cauchemar de performance. Toujours profiler avant d'optimiser.
  • py-spy est votre ami : Il est non intrusif, rapide, et vous donne une représentation visuelle de votre utilisation CPU. Que demander de plus ?
  • Pensez de manière algorithmique : Parfois, la meilleure optimisation est d'utiliser un algorithme plus efficace. La notation Big O n'est pas seulement pour les entretiens sur tableau blanc !
  • Les serveurs WSGI sont des bêtes complexes : Rappelez-vous, nous ne profilons pas seulement notre application, mais tout l'écosystème WSGI. C'est des tortues jusqu'en bas !

L'Épilogue : Restez Calme et Continuez à Profiler

Le profilage avec py-spy, c'est comme faire un bilan de santé à votre code. Cela peut révéler des vérités inconfortables, mais à la fin, votre application vous en remerciera. Et rappelez-vous, chaque milliseconde compte lorsque vous servez des requêtes web !

Alors, la prochaine fois que votre serveur WSGI Python commence à faire des siennes, ne paniquez pas. Prenez py-spy, générez ces graphiques en flamme, et commencez à traquer ces goulets d'étranglement CPU. Vos utilisateurs (et votre patron) vous en remercieront.

À méditer : Quelles autres parties de votre application pourraient bénéficier d'une session de profilage py-spy ? Requêtes de base de données ? Appels API externes ? Les possibilités sont infinies !

Maintenant, allez de l'avant et profilez, vous magnifique détective de code, vous !