Mon Django application est devenue douloureusement lente sur la production. Cela est probablement dû à des requêtes complexes ou non indexées.
Existe-t-il un moyen Django-ish de profiler mon application?
Essayez la Django Debug Toolbar . Il vous montrera quelles requêtes sont exécutées sur chaque page et combien de temps elles prennent. C'est un outil vraiment utile, puissant et facile à utiliser.
Lisez également les recommandations sur les performances de Django dans Optimisation de l'accès à la base de données dans la documentation.
Et Django performance tips par Jacob Kaplan-Moss.
Tapez simplement "Django-profiling" sur google, vous obtiendrez ces liens (et plus):
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/
Personnellement, j'utilise l'approche middleware - c'est-à-dire que chaque utilisateur peut basculer un indicateur de "profilage" stocké dans une session, et si mon middleware de profilage remarque qu'un indicateur a été défini, il utilise le module hotshot de Python comme cette:
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: Pour le profilage des requêtes SQL http://github.com/robhudson/Django-debug-toolbar mentionné par Konstantin est une bonne chose - mais si vos requêtes sont vraiment lentes (probablement parce qu'il y en a des centaines ou des milliers d'entre eux), alors vous attendez un temps fou jusqu'à ce qu'il soit chargé dans un navigateur - et puis il sera difficile de naviguer en raison de la lenteur. En outre, Django-debug-toolbar est par conception incapable de donner un aperçu utile des internes des requêtes AJAX.
EDIT2: Django-extensions a une grande commande de profilage intégrée:
https://github.com/Django-extensions/Django-extensions/blob/master/docs/runprofileserver.rst
Faites-le et le tour est joué:
$ mkdir /tmp/my-profile-data
$ ./manage.py runprofileserver --kcachegrind --prof-path=/tmp/my-profile-data
Pour le profilage de l'accès aux données (qui est la plupart du temps le goulot d'étranglement), consultez Django-live-profiler . Contrairement à Django Debug Toolbar, il collecte des données sur toutes les demandes simultanément et vous pouvez les exécuter en production sans trop de surcharge de performances ou d'exposer les internes de votre application.
Plug sans vergogne ici, mais j'ai récemment fait https://github.com/Django-silk/silk à cet effet. C'est un peu similaire à Django barre d'outils mais avec l'historique, le profilage de code et un contrôle plus fin sur tout.
Pour tous les fans de KCacheGrind, je trouve qu'il est très facile d'utiliser le Shell en tandem avec le fantastique test de Django Client
pour générer des journaux de profil à la volée, en particulier en production. J'ai utilisé cette technique maintenant à plusieurs reprises car elle a une touche légère - aucun middleware embêtant ou tierce partie Django sont requises!
Par exemple, pour profiler une vue particulière qui semble fonctionner lentement, vous pouvez ouvrir le Shell et taper ce code:
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()
Pour visualiser le journal résultant, j'ai utilisé hotshot2cachegrind:
Mais il existe également d'autres options:
Lorsque les vues ne sont pas HTML, par exemple JSON, utilisez des méthodes middleware simples pour le profilage.
Voici quelques exemples:
https://Gist.github.com/1229685 - capturer tous les appels sql entrés dans la vue
https://Gist.github.com/1229681 - profil tous les appels de méthode utilisés pour créer la vue