Profilage de Django

Mon application django est devenue extrêmement lente en 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 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

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 Clientpour 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:

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

Mais il existe également d'autres options:

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

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:

• Django Debug Toolbar est idéal si le problème est dû à des requêtes SQL et fonctionne bien en combinaison avecpyinstrument
• django-silk fonctionne bien, mais nécessite l'ajout d'un gestionnaire de contexte ou d'un décorateur à chaque partie de la pile où vous voulez des minutages de sous-requête. Il fournit également un moyen facile d'accéder aux cProfilehoraires et affiche automatiquement les horaires ajax, qui peuvent tous deux être très utiles.
• djdt-flamegraph avait l'air prometteur, mais la page n'a jamais été rendue sur mon système.

Comparé aux autres outils que j'ai essayés, pyinstrumentc'était considérablement plus facile à installer et à utiliser.