Laten we zeggen dat we een Flask-applicatie draaien op Gunicorn (omdat we zo cool zijn). We hebben een paar eindpunten, en een daarvan gedraagt zich vreemd. Tijd om onze py-spy bril op te zetten en te onderzoeken wat er aan de hand is.

Onze Verdachte: De CPU-Hongerige Handler

Hier is een eenvoudige Flask-app met een handler die duidelijk problemen veroorzaakt:


from flask import Flask
import time

app = Flask(__name__)

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

@app.route('/cpu_hog')
def cpu_hog():
    # Hier gebeurt de magie (lees: het probleem)
    result = 0
    for i in range(10000000):
        result += i
    return f"Ik heb tot {result} geteld. Ben je niet trots?"

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

Waarschuwing: Dat /cpu_hog eindpunt is onze hoofdverdachte.

Enter py-spy: Onze Profiling Sidekick

Eerst en vooral, laten we py-spy aan ons team toevoegen:


pip install py-spy

Nu starten we onze Gunicorn-server:


gunicorn app:app -w 4

Hier komt het leuke gedeelte. In een andere terminal laten we py-spy los op onze nietsvermoedende WSGI-server:


sudo py-spy record -o profile.svg --pid $(pgrep -f gunicorn) --subprocesses
Pro Tip: We gebruiken hier sudo omdat py-spy zich aan het proces moet hechten. Wees voorzichtig met sudo-macht, want met grote macht komt... nou ja, je kent de rest.

De Profiling Resultaten Ontcijferen: CSI: CPU Editie

Na een paar keer ons /cpu_hog eindpunt te hebben geraakt (ga je gang, we wachten wel), laten we eens kijken naar die prachtige SVG flame graph die py-spy voor ons heeft gegenereerd.

Flame Graph
Onze CPU-gebruik flame graph. Het is als een plaats delict, maar dan voor code.

Wat zien we? Een torenhoge vlam van CPU-gebruik in onze cpu_hog functie! Het is als het vinden van Waldo, als Waldo een prestatieknelpunt was in een gestreept shirt van inefficiëntie.

De Flame Graph Uitleggen

  • De breedte van elke balk vertegenwoordigt de tijd die in die functie is doorgebracht
  • De kleuren? Ze zijn gewoon mooi. Lees er niet te veel in.
  • Gestapelde balken tonen de call stack. Het is als een sandwich van traagheid.

Het Plot Dikt In: Onze Bevindingen Analyseren

Dus, wat hebben we geleerd van ons py-spy avontuur?

  1. Onze cpu_hog functie doet zijn naam eer aan. Het vreet CPU alsof het uit de mode raakt.
  2. De boosdoener? Die onschuldig ogende for lus. Het doet meer iteraties dan een wasmachine die vastzit in de centrifugecyclus.
  3. Onze andere eindpunten (zoals hello_world) zijn nauwelijks zichtbaar. Ze zijn de onbezongen helden van onze app.

Plotwending: Onze CPU Hog Optimaliseren

Nu we onze prestatieboosdoener op heterdaad hebben betrapt, laten we het verbeteren:


@app.route('/cpu_hog_reformed')
def cpu_hog_reformed():
    # Laten we een efficiëntere manier gebruiken om getallen op te tellen
    result = sum(range(10000001))
    return f"Ik heb efficiënt tot {result} geteld. Veel beter, toch?"

Voer py-spy opnieuw uit met dit nieuwe eindpunt, en voilà! Onze flame graph zou er minder uit moeten zien als een torenhoge vlam en meer als een gezellig kampvuur.

Geleerde Lessen: Het Py-spy Profiling Handboek

Welke wijsheden kunnen we meenemen van deze profiling escapade?

  • Vertrouw, maar verifieer: Zelfs eenvoudig ogende code kan een prestatie-nachtmerrie zijn. Profiel altijd voordat je optimaliseert.
  • py-spy is je vriend: Het is niet-intrusief, snel en geeft je een visuele weergave van je CPU-gebruik. Wat is er niet leuk aan?
  • Denk algoritmisch: Soms is de beste optimalisatie het gebruik van een efficiënter algoritme. Big O notatie is niet alleen voor whiteboard interviews!
  • WSGI-servers zijn complexe beesten: Vergeet niet, we profileren niet alleen onze app, maar het hele WSGI-ecosysteem. Het zijn schildpadden helemaal naar beneden!

De Epiloog: Blijf Kalm en Blijf Profileren

Profileren met py-spy is als het geven van een gezondheidscheck aan je code. Het kan enkele ongemakkelijke waarheden onthullen, maar uiteindelijk zal je applicatie je dankbaar zijn. En onthoud, elke milliseconde telt wanneer je webverzoeken bedient!

Dus, de volgende keer dat je Python WSGI-server zich vreemd begint te gedragen, raak niet in paniek. Pak py-spy, genereer die flame graphs, en begin die CPU-vreters op te sporen. Je gebruikers (en je baas) zullen je dankbaar zijn.

Stof tot Nadenken: Welke andere delen van je applicatie zouden kunnen profiteren van een py-spy profiling sessie? Database queries? Externe API-aanroepen? De mogelijkheden zijn eindeloos!

Ga nu en profileer, jij magnifieke code-detective, jij!