Remarque : Python 2.7 n'est plus compatible à partir du 31 janvier 2024. Vos applications Python 2.7 existantes continueront à fonctionner et à recevoir du trafic. Toutefois, App Engine peut bloquer le redéploiement des applications qui utilisent des environnements d'exécution après leur date de fin de compatibilité. Nous vous recommandons de migrer vers la dernière version compatible de Python.

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. Par exemple, 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 la section Gérer les ressources des applications.

Regarder une vidéo de démonstration.

Configuration

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. La méthode la plus simple consiste à définir un middleware WSGI pour encapsuler chaque application WSGI à l'aide de 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.

Pour plus d'informations sur appengine_config.py, consultez la section Configuration facultative ci-dessous
Framework Django

Pour installer le middleware Appstats dans une application Django, modifiez votre fichier settings.py et ajoutez la ligne suivante en tant que premier élément de la section MIDDLEWARE_CLASSES :
```
    MIDDLEWARE_CLASSES = (
  'google.appengine.ext.appstats.recording.AppStatsDjangoMiddleware',

  # ...
)
```
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 sur le répertoire par défaut (/_ah/stats/), ajoutez le builtin 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 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 accéder à un exemple complet d'options de configuration, reportez-vous au fichier google/appengine/ext/appstats/sample_appengine_config.py du SDK.

Éléments à connaître à propos de appengine_config.py :

Si vos gestionnaires de requêtes modifient sys.path, vous devez apporter les mêmes modifications à sys.path dans appengine_config.py de façon à ce que l'interface Web d'Appstats puisse accéder à 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 votre 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 de la console pour 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 :
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 :

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 :
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) affiche le temps total d'attente des appels RPC. La barre Grand Total (Total général) indique le temps total passé à traiter la demande. Comme vous pouvez le constater dans la chronologie ci-dessous, le temps a majoritairement été consacré aux appels RPC. Cette situation est fréquente. Les autres onglets contiennent des informations supplémentaires sur la demande Comprendre l'impact des appels RPC sur le temps de réponse de votre application est essentiel à l'analyse de ses performances.

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 à votre fichier appengine_config.py :
```
<pre suppresswarning="yes" class="prettyprint">
appstats_SHELL_OK = True
</pre>
```
Avertissement : Interactive Playground dispose du même accès à l'environnement et aux services de l'application qu'un fichier .py dans l'application elle-même. Soyez vigilant, car cela signifie que les écritures dans votre datastore seront réellement exécutées !

Fonctionnement

Appstats utilise des points d'ancrage (hooks) d'API pour s'ajouter à l'environnement logiciel d'appels de procédure à distance sous-jacent aux API de services App Engine. Il enregistre les statistiques pour tous les appels d'API émis par le gestionnaire de requêtes, puis stocke les données dans le cache mémoire en utilisant l'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.[REGION_ID].r.appspot.com/stats/detail?time=1234567890123
</pre>

Cette ligne indique la clé de cache mémoire mise à jour, la taille des enregistrements récapitulatifs (part) et détaillés (full), ainsi que la durée (en secondes) d'enregistrement de 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.