Ir para o console

Primeiros passos com o Monitoramento de desempenho para Android

Antes de começar

Adicione o Firebase ao projeto para Android, caso ainda não tenha feito isso.

Etapa 1: adicionar o Monitoramento de desempenho ao seu app

  1. No módulo (nível do app) do arquivo Gradle (geralmente app/build.gradle) faça o seguinte:

    • Adicione o plug-in do Gradle para o Monitoramento de desempenho.
    • Adicione a dependência para a biblioteca do Monitoramento de desempenho para Android.
    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.9'
    
        // Add the dependency for the Performance Monitoring library
        implementation 'com.google.firebase:firebase-perf:17.0.0'
    }
    
  2. No nível raiz (nível do projeto) do seu arquivo Gradle (build.gradle), adicione as regras para incluir o plug-in do Monitoramento de desempenho

    buildscript {
    
        repositories {
          // Add the following repositories:
          jcenter()  // Bintray's repository
          google()   // Google's Maven repository
        }
    
        dependencies {
          // ...
    
          classpath 'com.google.gms:google-services:4.2.0'  // Google Services plugin
    
          // Add the dependency for the Performance Monitoring plugin
          classpath 'com.google.firebase:perf-plugin:1.2.1'  // Performance Monitoring plugin
        }
    }
    
  3. Recompile o app.

O Firebase agora está monitorando os traces automáticos e as solicitações de rede HTTP/S.

Etapa 2: verificar o Console do Firebase para visualizar os resultados do Monitoramento de desempenho

  1. Crie o app no Android Studio.

  2. Teste seu app usando:

    • um emulador do Android com uma imagem recente e o Google Play Services 15.0.0 ou versões posteriores;

    • um dispositivo de teste com o Google Play Services 15.0.0 ou versões posteriores.

  3. Confirme se os resultados do Monitoramento de desempenho aparecem no Console do Firebase.

    Os resultados geralmente são exibidos em até 12 horas.

Etapa 3: adicionar métricas e traces personalizados (opcional)

Um trace personalizado é um relatório de dados de desempenho associados a algum código no app. Para saber mais sobre traces personalizados, consulte a visão geral do Monitoramento de desempenho.

É possível ter vários traces personalizados no app, além de manter mais de um deles em execução por vez. Cada trace personalizado pode ter uma ou mais métricas para contar eventos relacionados ao desempenho no app. Elas estão associadas aos traces que as criam.

Os nomes das métricas e dos traces personalizados precisam atender aos seguintes requisitos: não conter espaço em branco inicial ou final, não conter sublinhado (_) no início e ter no máximo de 32 caracteres.

  1. Importe essas classes do Monitoramento de desempenho na parte superior do arquivo .java ou .kt:

    import com.google.firebase.perf.FirebasePerformance;
    import com.google.firebase.perf.metrics.Trace;
    
  2. Para iniciar e interromper um trace personalizado, una o código que você quer rastrear com linhas de código semelhantes às seguintes (este exemplo usa test_trace como nome de trace personalizado):

    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 incluir uma métrica personalizada, adicione linhas de código semelhantes às seguintes toda vez que o evento ocorrer. Por exemplo, essa métrica personalizada conta os eventos relacionados ao desempenho que ocorrem no app, ocorrências e falhas do cache (e usa item_cache_hit e item_cache_miss como exemplos de nomes de eventos e um 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()
    

Etapa 4: rastrear métodos específicos usando @AddTrace (Opcional)

Adicione a anotação @AddTrace aos métodos do seu app e forneça uma string para identificar o trace personalizado resultante. Isso faz um trace iniciar com o método e parar junto com a conclusão dele.

Observe, no entanto, que nos traces personalizados que foram criados com a anotação @AddTrace, não é possível adicionar métricas personalizadas.

Por exemplo, para criar um trace onCreateTrace que seja executado quando o método onCreate() é chamado, use um código semelhante ao seguinte:

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

Etapa 5: adicionar o monitoramento a solicitações de rede específicas (opcional)

O Monitoramento de desempenho coleta solicitações de rede automaticamente. Isso inclui a maioria das solicitações de rede do seu aplicativo, mas algumas delas podem não ser relatadas.

Para incluir solicitações de rede personalizadas no Monitoramento de desempenho, adicione ao app o seguinte código:

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

As solicitações de rede HTTP/S capturadas especificamente dessa maneira aparecem no Console do Firebase com as solicitações de rede que o Monitoramento de desempenho captura automaticamente.

Etapa 6: implantar seu app e analisar os resultados

Depois de validar o Monitoramento de desempenho usando um ou mais dispositivos de teste, você poderá implantar a versão atualizada do seu app para os usuários.

É possível monitorar dados de desempenho no Console do Firebase.

Problemas conhecidos

  • O plug-in do Gradle v1.1.0 para o Monitoramento de desempenho pode causar uma incompatibilidade nas dependências do Guava, resultando no seguinte erro:

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

    Se você encontrar esse erro, faça o seguinte:

    • Atualize o plug-in do Monitoramento de desempenho para v1.1.1 ou versões posteriores. Lembre-se de que a mais recente é a v1.2.1.

    • Substitua a linha de dependência do plug-in do Monitoramento de desempenho no seu arquivo Gradle (build.gradle) no nível de raiz, ou seja, do projeto, da seguinte 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'
          }
        }
      }
      
  • O Monitoramento de desempenho só aceita solicitações de rede HTTP/S de monitoramento feitas usando o cliente HTTP OkHttp (em inglês) v3.xx.

  • O Monitoramento de desempenho relata o tamanho total do payload para solicitações de rede HTTP/S com base no valor definido no cabeçalho HTTP content-length. Esse valor pode não ser sempre exato.

  • O Monitoramento de desempenho só aceita o processo principal em apps Android multiprocessuais.

  • O plugin Gradle do Monitoramento de desempenho não é compatível com o seguinte:

    • DexGuard, que desativa os traces automáticos e o monitoramento de solicitações de rede HTTP/S. No entanto, os traces personalizados adicionados usando o SDK do Monitoramento de desempenho se comportarão normalmente se seu app usar o DexGuard.

    • Jack (em inglês), que está obsoleto.

Depurar sua integração

É possível ativar o registro de depuração para o Monitoramento de desempenho no momento da compilação adicionando um elemento <meta-data> ao arquivo AndroidManifest.xml do seu app da seguinte forma:

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

Você pode ver o registro de solicitação de trace e rede HTTP/S usando o filtro logcat. As mensagens de log do Monitoramento de desempenho são marcadas com FirebasePerformance, e é possível filtrá-las usando o seguinte comando:

adb logcat -s FirebasePerformance

Próximas etapas