Performance Monitoring collecte des traces pour vous aider à surveiller les performances de votre application. Une trace est un rapport sur les données de performances capturées entre deux moments dans votre application.
Vous pouvez créer vos propres traces pour surveiller les données de performances associées à un code spécifique dans votre application. Avec une trace de code personnalisée, vous pouvez mesurer le temps nécessaire à votre application pour effectuer une tâche spécifique ou un ensemble de tâches, par exemple charger un ensemble d'images ou interroger votre base de données.
La métrique par défaut d'une trace de code personnalisée est sa "durée" (temps écoulé entre le point de départ et le point d'arrêt de la trace), mais vous pouvez également ajouter des métriques personnalisées.
Dans votre code, vous définissez le début et la fin d'une trace de code personnalisée à l'aide des API fournies par le SDK Performance Monitoring.
Pour les applications Android, vous pouvez également surveiller des méthodes spécifiques à l'aide de l'annotation @AddTrace
.
Les traces de code personnalisées peuvent être démarrées à tout moment après leur création. Elles sont thread-safe.
Étant donné que la métrique par défaut collectée pour ces traces est "durée", elles sont parfois appelées "traces de durée".
Vous pouvez afficher les données de ces traces dans le sous-onglet Traces personnalisées de la table des traces, situé en bas du tableau de bord Performances (découvrez comment utiliser la console plus loin sur cette page).
Attributs par défaut, attributs personnalisés et métriques personnalisées
Pour les traces de code personnalisées, Performance Monitoring enregistre automatiquement les attributs par défaut (métadonnées courantes telles que la version de l'application, le pays, l'appareil, etc.) afin que vous puissiez filtrer les données de la trace dans la console Firebase. Vous pouvez également ajouter et surveiller des attributs personnalisés (tels que des niveaux de jeu ou des propriétés utilisateur).Vous pouvez également configurer une trace de code personnalisée pour enregistrer des métriques personnalisées pour les événements liés aux performances qui se produisent dans le champ d'application de la trace. Par exemple, vous pouvez créer une métrique personnalisée pour le nombre de succès et d'échecs de cache ou le nombre de fois où l'UI ne répond pas pendant une période notable.
Les attributs personnalisés et les métriques personnalisées s'affichent dans la console Firebase avec les attributs par défaut et la métrique par défaut de la trace.
Ajouter des traces de code personnalisées
Utilisez l'API Trace Performance Monitoring pour ajouter des traces de code personnalisées afin de surveiller un code d'application spécifique.
Veuillez noter les points suivants :
- Une application peut avoir plusieurs traces de code personnalisées.
- Plusieurs traces de code personnalisé peuvent s'exécuter simultanément.
- Les noms des traces de code personnalisées doivent répondre aux exigences suivantes: pas d'espace blanc de début ou de fin, pas de trait de soulignement au début (
_
), et la longueur maximale est de 100 caractères. - Les traces de code personnalisées prennent en charge l'ajout de métriques personnalisées et d'attributs personnalisés.
Pour démarrer et arrêter une trace de code personnalisée, encapsulez le code que vous souhaitez tracer avec des lignes de code semblables à celles-ci (cet exemple utilise un nom de trace personnalisé de test_trace
) :
Kotlin+KTX
// Import these Performance Monitoring classes at the top of your `.kt` file import com.google.firebase.perf.FirebasePerformance; import com.google.firebase.perf.metrics.Trace; val myTrace = Firebase.performance.newTrace("test_trace") myTrace.start() // code that you want to trace myTrace.stop()
Java
// Import these Performance Monitoring classes at the top of your `.java` file import com.google.firebase.perf.FirebasePerformance; import com.google.firebase.perf.metrics.Trace; Trace myTrace = FirebasePerformance.getInstance().newTrace("test_trace"); myTrace.start(); // code that you want to trace myTrace.stop();
(Facultatif) Surveiller des méthodes spécifiques à l'aide de @AddTrace
Les applications Android sont également compatibles avec l'annotation @AddTrace
pour instrumenter les traces de code personnalisées. Avec cette fonctionnalité, la trace commence au début de la méthode spécifiée et s'arrête lorsque la méthode se termine, y compris tout ce qui est appelé par la méthode.
Par exemple, vous pouvez créer une trace de code personnalisée appelée onCreateTrace
qui s'exécute lorsque la méthode onCreate()
est appelée.
Kotlin+KTX
// Import these Performance Monitoring classes at the top of your `.kt` file import com.google.firebase.perf.FirebasePerformance; import com.google.firebase.perf.metrics.AddTrace; // Add the `@AddTrace` annotation above the method you want to trace // the `enabled` argument is optional and defaults to true @AddTrace(name = "onCreateTrace", enabled = true) override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) }
Java
// Import these Performance Monitoring classes at the top of your `.java` file import com.google.firebase.perf.FirebasePerformance; import com.google.firebase.perf.metrics.AddTrace; // Add the `@AddTrace` annotation above the method you want to trace @Override @AddTrace(name = "onCreateTrace", enabled = true /* optional */) protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); }
Ajouter des métriques personnalisées aux traces de code personnalisées
Utilisez l'API Trace Performance Monitoring pour ajouter des métriques personnalisées aux traces de code personnalisées.
Veuillez noter les points suivants :
- Les noms des métriques personnalisées doivent respecter les conditions suivantes : pas d'espace blanc au début ni à la fin, pas de trait de soulignement (
_
) au début, et longueur maximale de 100 caractères. - Chaque trace de code personnalisée peut enregistrer jusqu'à 32 métriques (y compris la métrique Durée par défaut).
Pour ajouter une métrique personnalisée, ajoutez une ligne de code semblable à celle-ci chaque fois que l'événement se produit. Par exemple, cette métrique personnalisée comptabilise les événements liés aux performances qui se produisent dans votre application, tels que les succès de cache et les défauts de cache (en utilisant des exemples de noms d'événements item_cache_hit
et item_cache_miss
, avec un incrément de 1
).
Kotlin+KTX
val myTrace = Firebase.performance.newTrace("test_trace") myTrace.start() // code that you want to trace (and log custom metrics) val item = cache.fetch("item") if (item != null) { myTrace.incrementMetric("item_cache_hit", 1) } else { myTrace.incrementMetric("item_cache_miss", 1) } myTrace.stop()
Java
Trace myTrace = FirebasePerformance.getInstance().newTrace("test_trace"); myTrace.start(); // code that you want to trace (and log custom metrics) Item item = cache.fetch("item"); if (item != null) { myTrace.incrementMetric("item_cache_hit", 1); } else { myTrace.incrementMetric("item_cache_miss", 1); } myTrace.stop();
Créer des attributs personnalisés pour les traces de code personnalisées
Utilisez l'API Trace Performance Monitoring pour ajouter des attributs personnalisés aux traces de code personnalisées.Pour utiliser des attributs personnalisés, ajoutez à votre application du code qui définit l'attribut et l'associe à une trace de code personnalisé spécifique. Vous pouvez définir l'attribut personnalisé à tout moment entre le début et la fin de la trace.
Veuillez noter les points suivants :
Les noms des attributs personnalisés doivent répondre aux exigences suivantes:
- Aucun espace de début ou de fin, aucun caractère de soulignement (
_
) de début - Pas d'espaces
- La longueur maximale est de 32 caractères
- Les caractères autorisés pour le nom sont
A-Z
,a-z
et_
.
- Aucun espace de début ou de fin, aucun caractère de soulignement (
Chaque trace de code personnalisé peut enregistrer jusqu'à cinq attributs personnalisés.
Veuillez vous assurer que les attributs personnalisés ne contiennent aucune information permettant d'identifier personnellement un individu auprès de Google.
En savoir plus sur cette consigne
Kotlin+KTX
Firebase.performance.newTrace("test_trace").trace { // Update scenario. putAttribute("experiment", "A") // Reading scenario. val experimentValue = getAttribute("experiment") // Delete scenario. removeAttribute("experiment") // Read attributes. val traceAttributes = this.attributes }
Java
Trace trace = FirebasePerformance.getInstance().newTrace("test_trace"); // Update scenario. trace.putAttribute("experiment", "A"); // Reading scenario. String experimentValue = trace.getAttribute("experiment"); // Delete scenario. trace.removeAttribute("experiment"); // Read attributes. Map<String, String> traceAttributes = trace.getAttributes();
Suivre, afficher et filtrer les données de performances
Suivre des métriques spécifiques dans votre tableau de bord
Pour connaître l'évolution de vos métriques clés, ajoutez-les à votre tableau de métriques en haut du tableau de bord Performances. Vous pouvez identifier rapidement les régressions en observant les modifications d'une semaine à l'autre ou en vérifiant que les modifications récentes de votre code améliorent les performances.
Tableau de bord Firebase Performance Monitoring" />Pour ajouter une métrique à votre tableau de métriques, procédez comme suit:
- Accédez au tableau de bord des performances dans la console Firebase.
- Cliquez sur une fiche de métrique vide, puis sélectionnez une métrique existante à ajouter à votre tableau.
- Sur la fiche de métrique qui s'affiche, cliquez sur pour obtenir plus d'options, par exemple pour remplacer ou supprimer une métrique.
Le tableau de données métriques affiche les données métriques collectées au fil du temps, à la fois sous forme graphique et sous forme de pourcentage numérique.
En savoir plus sur l'utilisation du tableau de bord
Afficher les traces et leurs données
Pour afficher vos traces, accédez au tableau de bord Performances dans la console Firebase, faites défiler l'écran vers le bas jusqu'au tableau des traces, puis cliquez sur le sous-onglet approprié. Le tableau affiche certaines des principales métriques pour chaque trace. Vous pouvez même trier la liste en fonction du pourcentage de variation pour une métrique spécifique.
Performance Monitoring fournit une page de dépannage dans la console Firebase qui met en évidence les modifications des métriques. Vous pouvez ainsi facilement résoudre rapidement les problèmes de performances et minimiser leur impact sur vos applications et vos utilisateurs. Vous pouvez consulter la page de dépannage lorsque vous découvrez d'éventuels problèmes de performances, par exemple dans les scénarios suivants:
- Vous sélectionnez des métriques pertinentes dans le tableau de bord et vous remarquez un grand delta.
- Dans la table des traces, vous effectuez un tri pour afficher les deltas les plus grands en haut, et vous constatez une variation significative en pourcentage.
- Vous recevez une alerte par e-mail vous informant d'un problème de performances.
Vous pouvez accéder à la page de dépannage de différentes manières:
- Dans le tableau de bord des métriques, cliquez sur le bouton Afficher les détails de la métrique.
- Sur une carte de métrique, sélectionnez
. La page de dépannage affiche des informations sur la métrique que vous avez sélectionnée. > Afficher les détails - Dans le tableau des traces, cliquez sur un nom de trace ou sur une valeur de métrique dans la ligne associée à cette trace.
- Dans une alerte par e-mail, cliquez sur Examiner.
Lorsque vous cliquez sur un nom de trace dans le tableau des traces, vous pouvez ensuite examiner les métriques qui vous intéressent. Cliquez sur le bouton
- Filtrez par Version de l'application pour afficher les données sur une release antérieure ou la dernière version
- Filtrez les données par appareil pour savoir comment les anciens appareils gèrent votre application.
- Filtrez par Pays pour vous assurer que l'emplacement de votre base de données n'affecte pas une région spécifique.
Découvrez comment afficher les données de vos traces.
Étapes suivantes
Découvrez comment utiliser des attributs pour examiner les données sur les performances.
Découvrez comment suivre les problèmes de performances dans la console Firebase.
Configurez des alertes pour les modifications de code qui dégradent les performances de votre application. Par exemple, vous pouvez configurer une alerte par e-mail pour votre équipe si la durée d'une trace de code personnalisé spécifique dépasse un seuil que vous définissez.
- Affichez des rapports détaillés sur les sessions utilisateur, dans lesquels vous pouvez consulter une trace spécifique dans un contexte chronologique d'autres traces collectées au cours de la même session.