Appstats pour Python 2

Le SDK Python 2 inclut la bibliothèque Appstats utilisée pour profiler les performances RPC (Appel de procédure à distance) de votre application. Un RPC App Engine est un appel réseau aller-retour entre votre application et une API de service App Engine. Tous les appels d'API suivants sont des appels RPC :

  • Appels Datastore tels que ndb.get_multi(), ndb.put_multi() ou ndb.gql().
  • Appels Memcache tels que memcache.get() ou memcache.get_multi().
  • Appels URL Fetch tels que urlfetch.fetch().
  • Appels Mail tels que mail.send().

L'optimisation ou le débogage d'une application évolutive peut constituer un défi, car de nombreux problèmes risquent de générer des performances médiocres ou des coûts inattendus. Ces problèmes sont très difficiles à résoudre à l'aide des sources d'information habituelles, telles que les journaux ou les statistiques de durée des requêtes. La plupart des requêtes d'une application passent la majorité de leur temps à attendre que les appels réseau se terminent pour pouvoir être traitées.

Pour que votre application fonctionne rapidement, vous devez pouvoir répondre aux questions suivantes :

  • Votre application effectue-t-elle des appels RPC inutiles ?
  • Devrait-elle mettre en cache des données au lieu de répéter les appels RPC afin d'obtenir ces mêmes données ?
  • Votre application fonctionnerait-elle mieux si plusieurs requêtes étaient exécutées en parallèle plutôt qu'en série ?

La bibliothèque Appstats vous aide à répondre à ces questions et à vérifier que votre application utilise les appels RPC de la manière la plus efficace possible, tout en vous permettant de les profiler. Appstats vous permet de suivre tous les appels RPC pour une requête donnée et de générer des rapports sur la durée et le coût de chaque appel.

Optimiser l'utilisation des appels RPC de votre application peut également réduire votre facture. Consultez l'article Gérer l'utilisation des ressources d'une application.

Regarder une vidéo de démonstration.

Configurer

Il n'y a rien à importer ni à installer pour commencer à utiliser Appstats. Vous devez simplement configurer votre application, puis redéployer et accéder à la console Appstats comme décrit dans les étapes ci-dessous. La bibliothèque Appstats s'occupe du reste.

1. Installer l'enregistreur d'événements

Pour enregistrer des statistiques sur les requêtes Web, chaque gestionnaire de requêtes de votre application doit appeler Appstats. En fonction du framework utilisé par votre application, choisissez l'une des options suivantes :

  • Gestionnaires de requêtes WSGI

    Pour utiliser Appstats avec des gestionnaires de requêtes WSGI, y compris des infrastructures WSGI telles que webapp2, vous devez encapsuler votre application WSGI avec le middleware Appstats. Pour ce faire, le moyen le plus simple consiste à définir un middleware WSGI pour encapsuler toutes les applications WSGI à l'aide du fichier appengine_config.py.

    S'il n'existe pas déjà, créez un fichier nommé appengine_config.py dans le répertoire racine de votre application. Ajoutez la fonction suivante au fichier :

    def webapp_add_wsgi_middleware(app):
        from google.appengine.ext.appstats import recording
        app = recording.appstats_wsgi_middleware(app)
        return app

    Avant d'appeler votre application WSGI, l'environnement d'exécution importe ce fichier et appelle la fonction webapp_add_wsgi_middleware, si elle est trouvée.

    Consultez la section Configuration facultative ci-dessous pour en savoir plus sur appengine_config.py.

  • Framework Django

    Pour installer le middleware Appstats dans une application Django, modifiez votre fichier settings.py et ajoutez la ligne suivante comme premier élément de MIDDLEWARE_CLASSES :

    <pre suppresswarning="yes" class="prettyprint">
    MIDDLEWARE_CLASSES = (
      'google.appengine.ext.appstats.recording.AppStatsDjangoMiddleware',
    
      # ...
    )
    </pre>
    

    Le middleware Appstats doit être le premier élément pour que le profileur puisse inclure un autre middleware dans ses statistiques.

    Le cas échéant, le middleware Django appelle Appstats pour enregistrer des événements. Il n'est pas nécessaire de modifier d'autres parties du code d'application.

2. Définir le chemin d'accès à la console

La console Appstats est accessible en entrant une URL pour votre application dans un navigateur Web. Vous devez définir le chemin d'accès de l'URL de l'une des deux manières suivantes :

  • URL par défaut

    Pour mapper Appstats au répertoire par défaut (/_ah/stats/), ajoutez la fonction intégrée appstats à votre fichier app.yaml :

    runtime: python27
    api_version: 1
    threadsafe: yes
    
    builtins:
    - appstats: on
    
    handlers:
    - url: .*
      script: main.app
    
  • URL personnalisée

    Si vous devez mapper Appstats vers un répertoire autre que celui par défaut, vous pouvez utiliser la directive url dans le fichier app.yaml :

      - url: /stats.*
      script: google.appengine.ext.appstats.ui.app
      

3. Configuration facultative

Vous pouvez configurer le comportement d'Appstats en ajoutant du contenu au fichier appengine_config.py dans le répertoire racine de votre application. Pour un exemple complet des options de configuration, consultez le fichier google/appengine/ext/appstats/sample_appengine_config.py dans le SDK.

Ce qu'il faut savoir sur appengine_config.py :

  • Si vos gestionnaires de requêtes modifient sys.path, vous devez apporter les mêmes modifications à sys.path dans le fichier appengine_config.py afin que l'interface Web d'Appstats puisse afficher tous les fichiers.

Afficher les coûts

AppStats peut suivre le coût et la durée des RPC. Si votre application est assez rapide, mais coûte plus cher que prévu, recherchez les opérations qui sont plus coûteuses que prévu. Pour activer le suivi des coûts, définissez appstats_CALC_RPC_COSTS = True dans le fichier appengine_config.py.

4. Tester Appstats à partir du serveur de développement

Vous pouvez tester votre configuration Appstats avec le serveur de développement. Si vous avez configuré le chemin d'accès à la console de façon à utiliser l'URL par défaut ci-dessus, vous pouvez accéder à la console à l'adresse http://localhost:8080/_ah/stats/.

5. Déployer

Une fois satisfait de la configuration d'Appstats, déployez votre application. Si vous avez configuré le chemin d'accès à la console de façon à utiliser l'URL par défaut ci-dessus, vous pouvez accéder à la console à l'adresse http://your_app_id.appspot.com/_ah/stats.

Visite guidée de la console Appstats

La console Appstats fournit des informations générales sur les appels RPC effectués, les chemins d'URL demandés, l'historique des requêtes récentes et le détail des requêtes individuelles :

  • Le tableau RPC Stats (Statistiques RPC) affiche des statistiques pour chaque type d'appel RPC effectué par votre application. Cliquer sur le bouton Plus permet de développer l'entrée afin d'afficher une répartition des appels RPC par requête de chemin :

    capture d'écran

  • Le tableau Path Stats (Statistiques de chemin) affiche des statistiques pour chaque requête de chemin envoyée à votre application. Cliquer sur le bouton Plus permet de développer l'entrée afin d'afficher une répartition des requêtes de chemin par RPC :

    capture d'écran

    Si vous avez activé la fonctionnalité de Suivi des coûts d'API, les coûts s'afficheront également.

  • Le tableau Requests History (Historique des requêtes) affiche les données relatives aux requêtes individuelles. Cliquer sur un bouton Plus permet de développer l'entrée afin d'afficher une répartition par RPC. Cliquer sur un lien de requête permet d'afficher une chronologie pour la requête, y compris la durée d'un appel RPC individuel :

    capture d'écran

  • Le graphique Timeline (Chronologie) des appels RPC indique le moment auquel des appels RPC spécifiques ont été passés et le temps nécessaire au traitement des requêtes. La barre RPC Total (Total RPC) indique la durée totale d'attente des appels RPC et la barre Grand Total indique la durée totale consacrée au traitement d'une requête. Comme vous pouvez le constater dans la chronologie ci-dessous, la majorité du temps a été consacrée aux appels RPC. Cette situation est fréquente. Les autres onglets contiennent des informations supplémentaires sur la requête. Comprendre l'impact des appels RPC sur le temps de réponse de votre application est essentiel à l'analyse de ses performances.

    capture d'écran

  • Interactive Playground permet aux développeurs de saisir du code Python arbitraire dans un formulaire Web et de l'exécuter dans l'environnement de leur application.

    Une fois que vous avez accédé à Appstats, cliquez sur le lien correspondant à Interactive Playground. Un formulaire présentant une seule zone de texte s'affichera. Entrez le code Python de votre choix dans la zone de texte, puis envoyez le formulaire pour l'exécuter. Tous les résultats imprimés sur la sortie standard sont affichés à côté de la zone de texte, et une analyse de la chronologie des appels RPC générés par votre code est également affichée.

    Interactive Playground peut être activé ou désactivé. Dans le SDK, il est activé par défaut, mais désactivé par défaut dans l'environnement de production. Pour l'activer, ajoutez la ligne suivante au fichier appengine_config.py :

    <pre suppresswarning="yes" class="prettyprint">
    appstats_SHELL_OK = True
    </pre>
    

Fonctionnement

Appstats utilise des points d'ancrage d'API pour s'ajouter lui-même au framework d'appel de procédure à distance sous-jacent aux API de service d'App Engine. Il enregistre des statistiques pour tous les appels d'API effectués pendant l'exécution du gestionnaire de requêtes, puis stocke les données dans memcache, en utilisant un espace de noms __appstats__. Appstats conserve des statistiques pour les 1 000 requêtes les plus récentes. Ces données se composent d'un récapitulatif d'environ 200 octets chacun et de détails pouvant atteindre 100 Ko. Vous pouvez contrôler la quantité de détails de ces derniers enregistrements. (Consultez la section Configuration facultative et l'exemple de fichier de configuration.)

Les points d'ancrage (hooks) d'API augmentent quelque peu la charge des gestionnaires de requêtes. Appstats ajoute un message aux journaux, au niveau "info", pour signaler la quantité de ressources consommées par la bibliothèque Appstats elle-même. La ligne de journal ressemble à ceci :

<pre suppresswarning="yes" class="prettyprint">
INFO 2009-08-25 12:04:07,277 recording.py:290] Saved; key: __appstats__:046800, part: 160 bytes, full: 25278 bytes, overhead: 0.019 + 0.018; link: http://your_app_id.appspot.com/stats/detail?time=1234567890123
</pre>

Cette ligne indique la clé memcache qui a été mise à jour, la taille des enregistrements de résumé (part) et des détails (full), ainsi que le temps (en secondes) passé à enregistrer ces informations. La ligne de journal inclut le lien vers l'interface d'administration d'Appstats contenant les données liées à cet événement.