Ir a la consola

Primeros pasos con Performance Monitoring para Android

Antes de comenzar

Si aún no lo has hecho, agrega Firebase a tu proyecto de Android.

En el build.gradle file de nivel de proyecto, asegúrate de incluir el repositorio Maven de Google en las secciones buildscriptallprojects.

Paso 1: Agrega el SDK de Performance Monitoring a tu app

El SDK de Performance Monitoring permite supervisar los seguimientos de duración automáticos y cualquier seguimiento personalizado adicional de tu app.

  1. En el archivo Gradle (generalmente app/build.gradle) de tu módulo (nivel de app), agrega lo siguiente:

    // ...
    
    dependencies {
      // ...
    
      implementation 'com.google.firebase:firebase-core:17.0.1'
    
      // Add the dependency for the Performance Monitoring library
      implementation 'com.google.firebase:firebase-perf:18.0.1'
    }
    
  2. Vuelve a compilar la app.

Paso 2: Agrega el complemento de Performance Monitoring a tu app

El complemento Gradle de Performance Monitoring habilita la instrumentación que proporciona el procesamiento de anotaciones @AddTrace y la supervisión automática de solicitudes de red HTTP/S.

Para agregar el complemento de Performance Monitoring a tu app, sigue estos pasos:

  1. En el archivo Gradle (generalmente app/build.gradle) de tu módulo (nivel de app), agrega lo siguiente:

    apply plugin: 'com.android.application'
    // Apply the Performance Monitoring plugin
    apply plugin: 'com.google.firebase.firebase-perf'
    
    dependencies {
      // ...
    }
    
  2. Agrega reglas para incluir el complemento de Performance Monitoring al archivo Gradle (build.gradle) de nivel de raíz (nivel de proyecto).

    buildscript {
    
        repositories {
          // Check that you have the following line (if not, add it):
          google()  // Google's Maven repository
          // Add the Bintray repository
          jcenter()
        }
    
        dependencies {
          // ...
    
          // To benefit from the latest Performance Monitoring plugin features,
          // update your Android Gradle Plugin dependency to at least v3.4.0
          classpath 'com.android.tools.build:gradle:3.4.0'
    
          classpath 'com.google.gms:google-services:4.3.0'  // Google Services plugin
    
          // Add the dependency for the Performance Monitoring plugin
          classpath 'com.google.firebase:perf-plugin:1.3.1'  // Performance Monitoring plugin
        }
    }
    
  3. Vuelve a compilar la app.

Paso 3: Revisa Firebase console para ver los resultados de Performance Monitoring

  1. Crea la app en Android Studio.

  2. Prueba tu app con lo siguiente:

    • Un emulador de Android con una imagen reciente y servicios de Google Play versión 15.0.0 o posterior

    • Un dispositivo de prueba con servicios de Google Play versión 15.0.0 o posterior

  3. Comprueba que los resultados de Performance Monitoring aparezcan en Firebase console.

    Por lo general, los resultados aparecen en un plazo de 12 horas.

Paso 4: Agrega métricas y seguimientos personalizados (opcional)

Un seguimiento personalizado es un informe de los datos de rendimiento asociados con parte del código de la app. Para obtener más información sobre los seguimientos personalizados, consulta la descripción general de Performance Monitoring.

Puedes configurar varios seguimientos personalizados en la app y es posible ejecutar más de uno al mismo tiempo. Cada seguimiento personalizado puede tener una o más métricas para contar eventos relacionados con el rendimiento en la app. Estas métricas están asociadas con los seguimientos que las crean.

Ten en cuenta que los nombres de las métricas y de los seguimientos personalizados no deben tener espacios en blanco al inicio ni al final, no pueden comenzar con guion bajo (_) y no deben exceder los 32 caracteres.

  1. Importa estas clases de Performance Monitoring en la parte superior del archivo .java o .kt, como en este ejemplo:

    import com.google.firebase.perf.FirebasePerformance;
    import com.google.firebase.perf.metrics.Trace;
    
  2. Para iniciar o detener un seguimiento personalizado, une el código que quieres seguir con líneas de código similares a la siguiente (en este ejemplo, se usa un nombre de seguimiento personalizado de test_trace):

    Java

    Trace myTrace = FirebasePerformance.getInstance().newTrace("test_trace");
    myTrace.start();
    
    // code that you want to trace
    
    myTrace.stop();
    

    Kotlin

    val myTrace = FirebasePerformance.getInstance().newTrace("test_trace")
    myTrace.start()
    
    // code that you want to trace
    
    myTrace.stop()
    
  3. Para agregar una métrica personalizada, agrega líneas de código similares a la siguiente cada vez que ocurra el evento. Por ejemplo, esta métrica personalizada cuenta los eventos relacionados con el rendimiento que ocurren en tu app, como los aciertos y errores de caché (con nombres de eventos de ejemplo de item_cache_hit y item_cache_miss, además de un incremento de 1).

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

    Kotlin

    val myTrace = FirebasePerformance.getInstance().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()
    

Paso 5: Realiza un seguimiento de métodos específicos con @AddTrace @AddTrace

Puedes agregar la anotación @AddTrace a los métodos de tu app y proporcionar una string para identificar el seguimiento personalizado resultante. Esto hace que un seguimiento comience al principio de este método y se detenga cuando se completa el método.

Sin embargo, debes tener en cuenta que no puedes agregar métricas personalizadas en los seguimientos personalizados creados con la anotación @AddTrace.

Por ejemplo, para crear un seguimiento llamado onCreateTrace que se ejecuta cuando se llama al método onCreate(), usa un código similar al siguiente:

Java

@Override
@AddTrace(name = "onCreateTrace", enabled = true /* optional */)
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
}

Kotlin

@AddTrace(name = "onCreateTrace", enabled = true /* optional */)
override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
}

Paso 6: Agrega supervisión para solicitudes de red específicas (opcional)

Performance Monitoring recopila las solicitudes de red automáticamente. Si bien esto incluye la mayoría de las solicitudes de red para la app, es posible que no se informen todos los casos.

Para incluir solicitudes de red personalizadas en Performance Monitoring, agrega el siguiente código a la app:

Java

HttpMetric metric =
        FirebasePerformance.getInstance().newHttpMetric("https://www.google.com",
                FirebasePerformance.HttpMethod.GET);
final URL url = new URL("https://www.google.com");
metric.start();
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setDoOutput(true);
conn.setRequestProperty("Content-Type", "application/json");
try {
    DataOutputStream outputStream = new DataOutputStream(conn.getOutputStream());
    outputStream.write(data);
} catch (IOException ignored) {
}
metric.setRequestPayloadSize(data.length);
metric.setHttpResponseCode(conn.getResponseCode());
printStreamContent(conn.getInputStream());

conn.disconnect();
metric.stop();

Kotlin

val metric = FirebasePerformance.getInstance().newHttpMetric("https://www.google.com",
        FirebasePerformance.HttpMethod.GET)
val url = URL("https://www.google.com")
metric.start()
val conn = url.openConnection() as HttpURLConnection
conn.doOutput = true
conn.setRequestProperty("Content-Type", "application/json")
try {
    val outputStream = DataOutputStream(conn.outputStream)
    outputStream.write(data)
} catch (ignored: IOException) {
}

metric.setRequestPayloadSize(data.size.toLong())
metric.setHttpResponseCode(conn.responseCode)
printStreamContent(conn.inputStream)

conn.disconnect()
metric.stop()

Las solicitudes de red HTTP/S que capturas específicamente de esta manera aparecen en Firebase console junto con las solicitudes de red que Performance Monitoring captura automáticamente.

Paso 7: Implementa tu app y revisa los resultados

Después de validar Performance Monitoring mediante uno o más dispositivos de prueba, puedes implementar la versión actualizada de tu app en tus usuarios.

Puedes supervisar los datos de rendimiento en Firebase console.

Problemas conocidos

  • La versión 1.1.0 del complemento de Gradle de Performance Monitoring puede causar un desajuste en las dependencias de Guava, lo que genera el siguiente error:

    Error:Execution failed for task ':app:packageInstantRunResourcesDebug'.
    > com.google.common.util.concurrent.MoreExecutors.directExecutor()Ljava/util/concurrent/Executor;

    Si ves este error, tienes las siguientes alternativas:

    • Actualiza el complemento de Performance Monitoring a la versión 1.1.1 o posterior (la más reciente es la versión 1.3.1).

    • Reemplaza la línea de dependencia del complemento de Performance Monitoring en tu archivo de Gradle (build.gradle) de nivel de raíz (nivel de proyecto) de la siguiente forma:

      buildscript {
        // ...
      
        dependencies {
          // ...
      
          // Replace the standard Performance Monitoring plugin dependency line, as follows:
          classpath ('com.google.firebase:perf-plugin:1.1.0') {
                      exclude group: 'com.google.guava', module: 'guava-jdk5'
          }
        }
      }
      
  • Performance Monitoring solo es compatible con la supervisión de las solicitudes de red HTTP/S realizadas con el cliente HTTP OkHttp v3.x.x.

  • Performance Monitoring informa el tamaño total de la carga útil para las solicitudes de red HTTP/S según el valor configurado en el encabezado de longitud de contenido de HTTP. Es posible que este valor no siempre sea exacto.

  • Performance Monitoring solo admite el proceso principal en las apps para Android de varios procesos.

  • El complemento de Gradle de Performance Monitoring no es compatible con los siguientes elementos:

    • DexGuard, que inhabilita los seguimientos automáticos y la supervisión de las solicitudes de red HTTP/S. Sin embargo, los seguimientos personalizados agregados con el SDK de Performance Monitoring se comportan normalmente si la app usa DexGuard

    • Jack, que está obsoleto

Depura tu integración

Puedes habilitar el registro de depuración para Performance Monitoring en el momento de la compilación, si agregas un elemento <meta-data> al archivo AndroidManifest.xml de tu app, de esta forma:

<application>
    <meta-data
      android:name="firebase_performance_logcat_enabled"
      android:value="true" />
</application>

Puedes ver el registro de solicitudes de seguimiento y red HTTP/S mediante el filtro de logcat. Los mensajes de registro de Performance Monitoring están etiquetados con FirebasePerformance y puedes filtrarlos con el siguiente comando:

adb logcat -s FirebasePerformance

Próximos pasos