Plantages et exceptions

Ce document offre une présentation générale de la mesure des plantages et des exceptions à l'aide du SDK Google Analytics v4 pour Android.

Présentation

La mesure des plantages et des exceptions vous permet de mesurer le nombre et le type de plantages et d'exceptions interceptés et non détectés qui se produisent dans votre application. Une exception comporte les champs suivants:

Les données sur les plantages et les exceptions sont principalement disponibles dans le rapport "Plantages et exceptions".

Exceptions capturées

Les exceptions détectées (comme le délai d'inactivité occasionnel d'une connexion réseau lors d'une requête de données) sont des erreurs dans votre application que vous devez gérer dans votre application.

Mesurez une exception interceptée en définissant les valeurs du champ d'exception sur l'outil de suivi et en envoyant l'appel, comme dans cet exemple:

// Get tracker.
Tracker t =
    ((AnalyticsSampleApp) getActivity().getApplication()).getTracker(TrackerName.APP_TRACKER);

// Build and send exception.
t.send(new HitBuilders.ExceptionBuilder()
    .setDescription(getExceptionMethod() + ":" + getExceptionLocation())
    .setFatal(getExceptionFatal())
    .build());

Pour en savoir plus sur la méthode getTracker, consultez la section Configuration avancée.

package com.google.android.apps.mobileplayground;

import android.os.Bundle;
import android.support.v4.app.Fragment;
import android.view.LayoutInflater;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.ViewGroup;
import android.widget.Button;
import android.widget.CheckBox;
import android.widget.EditText;
import com.google.android.apps.mobileplayground.AnalyticsSampleApp.TrackerName;
import com.google.android.gms.analytics.GoogleAnalytics;
import com.google.android.gms.analytics.HitBuilders;
import com.google.android.gms.analytics.Tracker;

/**
 * Class to exercise Exception hits.
 */
public class ExceptionFragment extends Fragment {

  @Override
  public View onCreateView(LayoutInflater inflater, ViewGroup container,
      Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

    View view = inflater.inflate(R.layout.exception, container, false);

    final Button dispatchBtn = (Button) view.findViewById(R.id.btnDispatch);
    dispatchBtn.setOnClickListener(new OnClickListener() {
      @Override
      public void onClick(View v) {
        dispatch();
      }
    });

    final Button trackBtn = (Button) view.findViewById(R.id.trackBtn);
    trackBtn.setOnClickListener(new OnClickListener() {
      @Override
      public void onClick(View v) {
        track();
      }
    });
    return view;
  }

  private void dispatch() {
    GoogleAnalytics.getInstance(getActivity().getApplicationContext()).dispatchLocalHits();
  }

  private void track() {
    // Get tracker.
    Tracker t =
        ((AnalyticsSampleApp) getActivity().getApplication()).getTracker(TrackerName.APP_TRACKER);

    // Build and send exception.
    t.send(new HitBuilders.ExceptionBuilder()
        .setDescription(getExceptionMethod() + ":" + getExceptionLocation())
        .setFatal(getExceptionFatal())
        .build());
  }

  private boolean getExceptionFatal() {
    return ((CheckBox) getView().findViewById(R.id.isFatalChk)).isChecked();
  }

  private String getExceptionLocation() {
    return ((EditText) getView().findViewById(R.id.exceptionLocationEdit)).getText().toString();
  }

  private String getExceptionMethod() {
    return ((EditText) getView().findViewById(R.id.exceptionMethodEdit)).getText().toString();
  }
}

Mesure des exceptions non détectées

Les exceptions non détectées représentent des instances où votre application a rencontré des conditions inattendues au moment de l'exécution et sont souvent fatales, entraînant le plantage de l'application. Les exceptions non détectées peuvent être envoyées automatiquement à Google Analytics en définissant la valeur de configuration ga_reportUncaughtExceptions ou en utilisant la classe ExceptionReporter.

Configuration automatique

Pour envoyer automatiquement toutes les exceptions non détectées dans votre application à Google Analytics, ajoutez la ligne suivante à votre fichier de configuration XML :

<bool name="ga_reportUncaughtExceptions">true</bool>

Après l'envoi d'une exception à l'aide de la mesure automatique des exceptions, l'exception est transmise au gestionnaire d'exceptions par défaut de Thread.

Utiliser une implémentation avancée

Utilisez la classe ExceptionReporter pour implémenter la mesure automatique des exceptions non capturées si vous utilisez une implémentation avancée et que vous n'utilisez pas la valeur de configuration ga_reportUncaughtExceptions.

ExceptionReporter peut servir de gestionnaire d'exceptions non capturées par défaut pour un thread spécifique ou pour tous les threads de votre application. Après avoir envoyé une exception à Google Analytics, la classe ExceptionReporter peut éventuellement la transmettre à un gestionnaire d'exceptions non détecté que vous fournissez.

Le code suivant crée un objet ExceptionReporter et le définit comme nouveau gestionnaire d'exceptions non capturés par défaut. Par conséquent, chaque exception non détectée est envoyée à Google Analytics, puis transmise à l'ancien gestionnaire d'exceptions non capturées. Pour la plupart des applications, le gestionnaire par défaut consigne l'exception dans le journal et arrête l'application.

Thread.UncaughtExceptionHandler myHandler = new ExceptionReporter(
    myTracker,
    Thread.getDefaultUncaughtExceptionHandler(),
    context);

// Make myHandler the new default uncaught exception handler.
Thread.setDefaultUncaughtExceptionHandler(myHandler);

Lorsque vous utilisez la mesure automatique des exceptions, gardez à l'esprit les points suivants:

• Toutes les exceptions envoyées à l'aide de la mesure automatique des exceptions sont signalées comme fatales dans Google Analytics.
• Par défaut, le champ de description est automatiquement défini à l'aide du type d'exception, du nom de classe, du nom de la méthode et du nom du thread.

Descriptions des exceptions d'analyse

Le SDK fournit un StandardExceptionParser pour simplifier le processus d'obtention et d'envoi de descriptions d'exceptions à Google Analytics :

// Get tracker.
Tracker t = ((AnalyticsSampleApp) getActivity().getApplication()).getTracker(
    TrackerName.APP_TRACKER);

// Using StandardExceptionParser to get an Exception description.
try {
    // Request some scores from the network.
    ArrayList<Integer> highScores = getHighScoresFromCloud();
} catch (IOException e) {
    t.send(new HitBuilders.ExceptionBuilder()
        .setDescription(new StandardExceptionParser(this, null)
            .getDescription(Thread.currentThread().getName(), e))
        .setFatal(false)
        .build()
    );

    ... // Display alert to user that high scores are currently unavailable.
}

Vous pouvez également implémenter votre propre analyseur en implémentant l'interface ExceptionParser et en appelant sa méthode setDescription lors de l'envoi d'une exception à Google Analytics.