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.

No arquivo build.gradle file do nível do projeto, certifique-se de incluir o repositório Maven do Google nas seções buildscript e allprojects.

Etapa 1: adicionar o SDK do Monitoramento de desempenho ao seu app

Com o SDK do Monitoramento de desempenho, é possível realizar o monitoramento de traces automáticos de duração e de qualquer outro trace personalizado no seu app.

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

    // ...
    
    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. Compile novamente o app.

Etapa 2: adicionar o plug-in do Monitoramento de desempenho ao seu app

Com o plug-in do Gradle para o Monitoramento de desempenho, é possível realizar a instrumentação que fornece processamento de anotações @AddTrace e monitoramento automático de solicitações de rede HTTP/S.

Para adicionar o plug-in do Monitoramento de Desempenho ao seu app:

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

    apply plugin: 'com.android.application'
    // Apply the Performance Monitoring plugin
    apply plugin: 'com.google.firebase.firebase-perf'
    
    dependencies {
      // ...
    }
    
  2. No nível raiz (nível do projeto) do seu arquivo do Gradle (build.gradle), adicione as regras para incluir o plug-in do Monitoramento de desempenho.

    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. Compile novamente o app.

Etapa 3: 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 4: 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 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, esta métrica personalizada conta eventos relacionados ao desempenho que ocorrem no app, como 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 5: rastrear métodos específicos por meio do @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() for 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 6: 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 7: implantar seu app e analisar os resultados

Depois de validar o Monitoramento de desempenho usando um ou mais dispositivos de teste, será possível 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, realize as seguintes ações:

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

    • Substitua a linha de dependência do plug-in do Monitoramento de desempenho no seu arquivo do Gradle (build.gradle) no nível da raiz (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 plug-in 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 o 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ções de rede HTTP/S e traces usando o filtro logcat. As mensagens de registro 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