Ir a la consola

Comienza a usar Firebase Performance Monitoring para Android

Antes de comenzar

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

Paso 1: Agrega Performance Monitoring a la app

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

    • Agrega el complemento de Gradle de Performance Monitoring.
    • Agrega la dependencia de la biblioteca para Android de Performance Monitoring.
    apply plugin: 'com.android.application'
    // Apply the Performance Monitoring plugin to enable instrumentation
    apply plugin: 'com.google.firebase.firebase-perf'
    
    dependencies {
        // ...
    
        implementation 'com.google.firebase:firebase-core:16.0.8'
    
        // Add Performance Monitoring dependency line
        implementation 'com.google.firebase:firebase-perf:16.2.5'
    }
    
  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):
          jcenter()
    
          // ...
        }
    
        dependencies {
          // ...
          classpath 'com.google.gms:google-services:4.2.0'  // Google Services plugin
    
          // Add the following line:
          classpath 'com.google.firebase:perf-plugin:1.2.0'  // Performance Monitoring plugin
        }
    }
    
  3. Vuelve a compilar la app.

Firebase ahora supervisa los seguimientos automáticos y las solicitudes de red HTTP/S.

Paso 2: 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 3: (Opcional) Agrega métricas y seguimientos personalizados

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.

  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. Antes del código en el que quieres iniciar un seguimiento en la app, agrega la siguiente línea de código para iniciar un seguimiento llamado test_trace:

    Java
    Android

    Trace myTrace = FirebasePerformance.getInstance().newTrace("test_trace");
    myTrace.start();

    Kotlin
    Android

    val myTrace = FirebasePerformance.getInstance().newTrace("test_trace")
    myTrace.start()
  3. Para contar los eventos relacionados con el rendimiento que ocurren en tu app (como aciertos o errores de caché), agrega líneas de código similares a la siguiente cada vez que se produzca uno. Usa una string que no sea item_cache_hititem_cache_miss para nombrar ese evento si cuentas eventos de un tipo diferente:

    Java
    Android

    Item item = cache.fetch("item");
    if (item != null) {
        myTrace.incrementMetric("item_cache_hit", 1);
    } else {
        myTrace.incrementMetric("item_cache_miss", 1);
    }

    Kotlin
    Android

    val item = cache.fetch("item")
    if (item != null) {
        myTrace.incrementMetric("item_cache_hit", 1)
    } else {
        myTrace.incrementMetric("item_cache_miss", 1)
    }
  4. Después del código donde deseas detener el seguimiento, agrega la siguiente línea:

    Java
    Android

    myTrace.stop();

    Kotlin
    Android

    myTrace.stop()

Paso 4: (Opcional) Haz seguimiento de métodos específicos con @AddTrace

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

Sin embargo, ten en cuenta que los seguimientos creados de esta manera no tienen métricas disponibles.

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

Java
Android

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

Kotlin
Android

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

Paso 5: (Opcional) Agrega supervisión para solicitudes de red específicas

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
Android

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
Android

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 6: 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 v1.2.0).

    • Reemplaza la línea de dependencia del complemento de Performance Monitoring en tu archivo de Gradle a nivel de raíz (nivel de proyecto) (build.gradle), 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

Pasos siguientes