Bloqueos y excepciones

En este documento, se proporciona una descripción general de alto nivel sobre la medición de fallas y excepciones con la versión 4 del SDK de Google Analytics para Android.

Descripción general

La medición de fallas y excepciones te permite medir la cantidad y el tipo de fallas detectadas y no detectadas, así como excepciones que ocurren en tu app. Las excepciones tienen los siguientes campos:

Nombre del campo	Tipo	Obligatorio	Descripción
Descripción	String	No	Una descripción de la excepción (hasta 100 caracteres). Acepta null.
isFatal	boolean	Sí	Indica si la excepción fue irrecuperable. true indica irrecuperable.

Los datos de fallas y excepciones están disponibles, principalmente, en el informe de fallas y excepciones.

Excepciones detectadas

Las excepciones capturadas, como el tiempo de espera ocasional de una conexión de red durante una solicitud de datos, son errores en tu app para los que implementaste código.

Para medir una excepción detectada, configura los valores del campo de excepción en el rastreador y envía el hit, como en este ejemplo:

// 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());

Consulta Configuración avanzada para obtener detalles sobre el método getTracker.

Cómo ver un fragmento de código de la aplicación de ejemplo

En el siguiente fragmento, se muestra un Fragment de ejemplo que envía una excepción:

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();
  }
}

Advertencia: Nunca envíes el mensaje de excepción (por ejemplo, e.getMessage()) a Google Analytics, ya que puede contener información de identificación personal.

Medición de excepciones no detectadas

Las excepciones sin detectar representan instancias en las que la app encontró condiciones inesperadas durante el tiempo de ejecución y, a menudo, son irrecuperables, lo que provocaba una falla en la app. Las excepciones sin detectar se pueden enviar automáticamente a Google Analytics cuando se establece el valor de configuración ga_reportUncaughtExceptions o se usa la clase ExceptionReporter.

Configuración automática

Para enviar todas las excepciones no detectadas en tu app automáticamente a Google Analytics, agrega esta línea a tu archivo de configuración XML:

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

Después de enviar una excepción con la medición automática de excepciones, la excepción se pasará al controlador de excepciones predeterminado de Thread.

Nota: Este valor solo se puede establecer en true para un único rastreador. Si se especifica para varios segmentos, se usará el último que se inicialice.

Cómo usar una implementación avanzada

Usa la clase ExceptionReporter para implementar la medición automática de excepciones no detectadas si usas una implementación avanzada y no usas el valor de configuración ga_reportUncaughtExceptions.

ExceptionReporter puede funcionar como el controlador predeterminado de excepciones no detectadas para un subproceso específico o todos los subprocesos de tu app. Después de enviar una excepción a Google Analytics, la clase ExceptionReporter puede, de manera opcional, pasar la excepción a un controlador de excepciones no detectadas que proporciones.

Con el siguiente código, se crea un objeto ExceptionReporter nuevo y se establece como el nuevo controlador de excepciones no detectadas predeterminado. Como resultado, cada excepción no detectada se enviará a Google Analytics y, luego, se pasará al controlador de excepciones no detectadas anterior. Para la mayoría de las aplicaciones, el controlador predeterminado registrará la excepción en el registro y finalizará la aplicación.

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

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

Cuando utilices la medición automática de excepciones, ten en cuenta lo siguiente:

• Todas las excepciones que se envían con la medición automática de excepciones se informan como irrecuperables en Google Analytics.
• De forma predeterminada, el campo de descripción se configura automáticamente con el tipo de excepción, el nombre de clase, el nombre del método y el nombre del subproceso.

Análisis de descripciones de excepciones

El SDK proporciona un StandardExceptionParser para simplificar el proceso de obtener y enviar descripciones de excepciones a 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.
}

También puedes implementar tu propio analizador. Para ello, implementa la interfaz ExceptionParser y llama a su método setDescription cuando envíes una excepción a Google Analytics.