Profilazione Django

La mia applicazione django è diventata dolorosamente lenta nella produzione. Probabilmente è dovuto ad alcune query complesse o non indicizzate.

Esiste un modo django per profilare la mia applicazione?

Prova la barra degli strumenti di debug di Django . Ti mostrerà quali query vengono eseguite su ciascuna pagina e quanto tempo impiegano. È uno strumento davvero utile, potente e facile da usare.

Inoltre, leggi i consigli sulle prestazioni di Django nell'ottimizzazione dell'accesso al database dalla documentazione.

E i suggerimenti per l' esecuzione di Django di Jacob Kaplan-Moss.

Basta digitare "django-profiling" su google, otterrai questi link (e altro):

http://code.djangoproject.com/wiki/ProfilingDjango

http://code.google.com/p/django-profiling/

http://www.rkblog.rk.edu.pl/w/p/django-profiling-hotshot-and-kcachegrind/

Personalmente sto utilizzando l'approccio middleware, ovvero ogni utente può attivare o disattivare un flag di "profilazione" memorizzato in una sessione, e se il mio middleware di profilazione nota che è stato impostato un flag, utilizza il modulo hotshot di Python in questo modo:

def process_view(self, request, view_func, view_args, view_kwargs):

     # setup things here, along with: settings.DEBUG=True 
     # to get a SQL dump in connection.queries

     profiler = hotshot.Profile(fname)
     response = profiler.runcall(view_func, request, *view_args, **view_kwargs)
     profiler.close()

     # process results

     return response

EDIT: per la profilazione delle query SQL http://github.com/robhudson/django-debug-toolbar menzionata da Konstantin è una cosa carina, ma se le tue query sono molto lente (probabilmente perché ce ne sono centinaia o migliaia), allora tu Aspetterò una folle quantità di tempo prima che venga caricato in un browser, dopodiché sarà difficile navigare a causa della lentezza. Inoltre, django-debug-toolbar non è in grado di fornire informazioni utili sugli interni delle richieste AJAX.

EDIT2: django-extensions ha un ottimo comando di profilazione integrato:

https://github.com/django-extensions/django-extensions/blob/master/docs/runprofileserver.rst

Basta fare questo e voilà:

$ mkdir /tmp/my-profile-data
$ ./manage.py runprofileserver --kcachegrind --prof-path=/tmp/my-profile-data

Per l'accesso ai dati di profilazione (che è dove il collo di bottiglia è la maggior parte del tempo) controlla django-live-profiler . A differenza di Django Debug Toolbar, raccoglie i dati su tutte le richieste contemporaneamente e puoi eseguirlo in produzione senza un sovraccarico eccessivo delle prestazioni o esponendo le parti interne dell'app.

Spudorato plug qui, ma di recente ho creato https://github.com/django-silk/silk per questo scopo. È in qualche modo simile alla barra degli strumenti di django ma con cronologia, profilazione del codice e controllo più dettagliato su tutto.

Per tutti voi fan di KCacheGrind, trovo che sia molto facile usare la shell in tandem con il fantastico test di Django Clientper generare al volo i log dei profili, specialmente in produzione. Ho usato questa tecnica in diverse occasioni perché ha un tocco leggero: non sono richiesti fastidiosi middleware o applicazioni Django di terze parti!

Ad esempio, per profilare una vista particolare che sembra funzionare lentamente, potresti aprire la shell e digitare questo codice:

from django.test import Client
import hotshot

c = Client()
profiler = hotshot.Profile("yourprofile.prof")  # saves a logfile to your pwd
profiler.runcall(c.get, "/pattern/matching/your/view/")
profiler.close()

Per visualizzare il registro risultante, ho usato hotshot2cachegrind:

• http://kcachegrind.sourceforge.net/html/ContribPython.html

Ma ci sono anche altre opzioni:

• http://www.vrplumber.com/programming/runsnakerun/
• https://code.djangoproject.com/wiki/ProfilingDjango

Quando le visualizzazioni non sono HTML, ad esempio JSON, utilizzare metodi middleware semplici per la profilazione.

Ecco un paio di esempi:

https://gist.github.com/1229685 - cattura tutte le chiamate sql entrate nella visualizzazione

https://gist.github.com/1229681 - profila tutte le chiamate ai metodi utilizzate per creare la vista

Di recente avevo bisogno di creare il profilo di un'app Django e ho provato molti di questi suggerimenti. Ho finito per usare invece pyinstrument , che può essere aggiunto a un'app Django utilizzando un singolo aggiornamento all'elenco middleware e fornisce una visualizzazione basata sullo stack dei tempi.

Breve riepilogo della mia esperienza con altri strumenti:

• Django Debug Toolbar è ottimo se il problema è dovuto a query SQL e funziona bene in combinazione conpyinstrument
• django-silk funziona bene, ma richiede l'aggiunta di un gestore di contesto o di un decoratore a ciascuna parte dello stack in cui desideri i tempi delle richieste secondarie. Fornisce inoltre un modo semplice per accedere ai cProfiletempi e visualizza automaticamente i tempi ajax, entrambi i quali possono essere davvero utili.
• djdt-flamegraph sembrava promettente, ma la pagina non è mai stata effettivamente visualizzata sul mio sistema.

Rispetto agli altri strumenti che ho provato, è pyinstrumentstato notevolmente più facile da installare e da utilizzare.