Réponses:
Essayez la barre d'outils Django Debug . 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 l' optimisation de l' accès à la base de données dans la documentation.
Et les conseils de performance Django de 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 ceci:
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), alors vous J'attendrai un temps fou jusqu'à ce qu'il soit chargé dans un navigateur - et il sera alors difficile de naviguer en raison de la lenteur. De plus, django-debug-toolbar est, de par sa conception, incapable de donner un aperçu utile des éléments internes des requêtes AJAX.
EDIT2: django-extensions a une excellente commande de profilage intégrée:
https://github.com/django-extensions/django-extensions/blob/master/docs/runprofileserver.rst
Faites juste ceci et voila:
$ mkdir /tmp/my-profile-data
$ ./manage.py runprofileserver --kcachegrind --prof-path=/tmp/my-profile-data
python manage.py runprofileserver --prof-path=/path/to/dir
, suivez ce blog: darkcoding.net/software/profiling-django-for-cpu-bound-apps .
hotshot
a été obsolète et supprimé dans Python 3, donc cette réponse et la ProfilingDjango
page Wiki peuvent ne plus être pertinentes en 20202.
Pour le profilage de l'accès aux données (où se trouve 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 l'exécuter en production sans trop de surcharge de performances ni d'exposer les composants internes de votre application.
Plug sans vergogne ici, mais j'ai récemment créé https://github.com/django-silk/silk à cet effet. C'est un peu similaire à la barre d'outils django mais avec un historique, un 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 application Django tierce n'est requis!
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 - capture tous les appels SQL sont entrés dans la vue
https://gist.github.com/1229681 - profile tous les appels de méthode utilisés pour créer la vue
J'avais récemment besoin de profiler une application Django et j'ai essayé plusieurs de ces suggestions. J'ai fini par utiliser pyinstrument à la place , qui peut être ajouté à une application Django en utilisant une seule mise à jour de la liste middleware et fournit une vue basée sur la pile des timings.
Résumé rapide de mon expérience avec certains autres outils:
pyinstrument
cProfile
horaires et affiche automatiquement les horaires ajax, qui peuvent tous deux être très utiles.Comparé aux autres outils que j'ai essayés, pyinstrument
c'était considérablement plus facile à installer et à utiliser.