Primeiros passos com o Monitoramento de desempenho do Firebase

Este guia mostra como usar o Monitoramento de desempenho do Firebase com seu aplicativo, seguindo estas etapas:

  1. Pré-requisitos
  2. Adicionar o Firebase ao projeto para Android
  3. Adicionar o Monitoramento de desempenho ao app
  4. (Opcional) Definir um trace personalizado e uma ou mais métricas no app
  5. (Opcional) Adicionar a anotação @AddTrace para gerar o trace em métodos específicos
  6. Verificar os resultados do Monitoramento de desempenho no Console do Firebase
  7. Implantar o app e analisar os resultados no Console do Firebase

Pré-requisitos

Antes de começar, é preciso configurar o ambiente com:

  • um dispositivo com Android 4.1 (Jelly Bean) ou uma versão mais recente do sistema operacional e o Google Play Services 16.2.4 ou superior;
  • o SDK do Google Play Services do Repositório do Google, disponível no Gerenciador do SDK do Android;
  • a versão mais recente do Android Studio 2.2 ou posterior.

Adicionar o Firebase ao projeto para Android

Se você estiver usando outros recursos do Firebase, poderá adicionar o Firebase ao app pelo Android Studio usando o Firebase Assistente.

Para abrir o Firebase Assistente no Android Studio:

  1. Clique em Ferramentas > Firebase para abrir a janela Assistente.
  2. Clique para expandir um dos recursos listados (por exemplo, Analytics) e clique no link do tutorial fornecido (por exemplo, Registrar um evento do Analytics).
  3. Clique no botão Conectar ao Firebase para se conectar ao Firebase e adicionar o código necessário ao app.

Se você não estiver usando outros recursos do Firebase no app, adicione o Firebase manualmente.

Adicionar o Monitoramento de desempenho ao app

  1. Abra o arquivo build.gradle de nível do projeto e adicione o seguinte:
    1. Na seção buildscript -> repositories:
      jcenter()
    2. Na seção buildscript -> dependencies, adicione a dependência do Firebase:
      • Para Android Studio 2.x:
        classpath 'com.google.firebase:firebase-plugins:1.1.1'
      • Para Android Studio 3.x:
        classpath 'com.google.firebase:firebase-plugins:1.1.5'
  2. Abra o arquivo build.gradle no nível do app e adicione o seguinte:
    1. Abaixo de apply plugin: 'com.android.application', adicione a seguinte linha:
      apply plugin: 'com.google.firebase.firebase-perf'
    2. Adicione o seguinte à seção dependencies:
      implementation 'com.google.firebase:firebase-perf:16.2.4'
  3. Recompile o app. Os traces automáticos e as solicitações de rede HTTP/S agora serão monitorados.

(Opcional) Definir um trace personalizado e uma ou mais métricas no app

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. Você pode ter vários traces personalizados no app, e é possível ter 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.

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

    Android

    import com.google.firebase.perf.FirebasePerformance;
    import com.google.firebase.perf.metrics.Trace;
  2. Imediatamente antes do código em que você pretende iniciar um trace no app, adicione a seguinte linha para iniciar um trace denominado 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 contabilizar os eventos relacionados ao desempenho que ocorrem no app (como acertos e erros do cache), adicione uma linha de código parecida com a seguinte toda vez que o evento ocorrer. Use uma string diferente de item_cache_hit ou item_cache_miss para nomear esse evento se você estiver contabilizando um tipo diferente de evento:

    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. Imediatamente após o código em que você pretende interromper o trace, adicione a seguinte linha de código:

    Java
    Android

    myTrace.stop();

    Kotlin
    Android

    myTrace.stop()

(Opcional) Adicionar a anotação @AddTrace para gerar traces em métodos específicos

Você pode adicionar a anotação @AddTrace aos métodos do app e fornecer uma string para identificar o trace resultante. Isso faz um trace iniciar com o método e parar junto com a conclusão dele. Os traces criados dessa maneira não têm métricas disponíveis.

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

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

Verificar os resultados do Monitoramento de desempenho no Console do Firebase

  1. Crie o app no Android Studio.
  2. Teste seu app usando um emulador Android com uma imagem recente e o Google Play Services 15.0.0 ou posterior. Se preferir, use um dispositivo de teste com o Google Play Services 15.0.0 ou posterior.
  3. Confirme se os resultados do Monitoramento de desempenho aparecem no Console do Firebase. Os resultados aparecerão dentro de 12 horas.

Implantar o app e analisar os resultados no Console do Firebase

Depois de validar o Monitoramento de desempenho usando um ou mais dispositivos de teste, você pode implantar a versão atualizada do app para seus usuários e usar o Console do Firebase para monitorar dados de desempenho.

(Opcional) Adicionar o monitoramento para solicitações de rede específicas

O Monitoramento de desempenho coleta solicitações de rede automaticamente. Embora isso inclua a maioria das solicitações de rede do seu aplicativo, algumas delas podem não ser relatadas. Para incluir solicitações de rede específicas no Monitoramento de desempenho, adicione o seguinte código ao seu 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()

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.

(Opcional) Analisar uma amostra de traces e solicitações de rede

Saiba mais sobre os segmentos de traces específicos ou solicitações de rede no Console do Firebase. Uma amostragem aleatória de sessões gravadas exibe as seguintes informações:

uma imagem da página de sessões do Monitoramento de desempenho do Firebase

  • CPU: o SDK do Monitoramento de desempenho captura quanto tempo do usuário e do sistema é consumido pelo aplicativo.
  • Memória: o SDK do Monitoramento de desempenho captura a quantidade de memória heap usada pelo aplicativo. Memória heap é a memória usada para alocações dinâmicas, incluindo objetos criados, desalocados e que o aplicativo está usando ativamente.
  • Informações individuais: informações detalhadas sobre uma única instância de uma solicitação de trace ou rede, incluindo a hora de início e de término, a duração, o tamanho da solicitação e o tamanho da resposta.
  • Instâncias simultâneas: informações sobre traces ou solicitações de rede que ocorreram ao mesmo tempo.
  • Atributos do dispositivo: informações sobre o dispositivo, incluindo versão do aplicativo, modelo, versão do sistema operacional, rádio e atributos personalizados.

Para visualizar essas amostras detalhadas no Console do Firebase, abra um dos traces ou solicitações de rede do seu aplicativo e clique em Ver sessões. Como alternativa, clique no link para as sessões do atributo específico.

uma imagem do trace do Monitoramento de desempenho do Firebase com um link para as sessões

As sessões que o Monitoramento de desempenho coleta são distribuídas em percentis para cada métrica. As sessões em percentis menores têm métricas com valores mais baixos do que as sessões em percentis mais altos. Para filtrar as sessões disponíveis por percentil, use o menu suspenso acima dos detalhes das sessões.

uma imagem da página de sessões do Monitoramento de desempenho do Firebase

Problemas conhecidos

  • O plug-in do Firebase versão 1.1.0 pode causar incompatibilidade nas dependências do Guava, ocasionando o 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 upgrade para a versão 1.1.1 ou substitua a instrução classpath mostrada acima pelo seguinte na seção buildscript -> dependencies do arquivo build.gradle de nível de projeto:

    classpath ('com.google.firebase:firebase-plugins:1.1.0') {
                exclude group: 'com.google.guava', module: 'guava-jdk5'
    }
  • O Monitoramento de desempenho só aceita monitoramento de solicitações de rede HTTP/S feitas com o cliente de HTTP OkHttp versão 3.x.x.
  • 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 com.google.firebase.firebase-perf do Gradle não é compatível com o DexGuard, o que desativa traces automáticos e o monitoramento de solicitações de rede HTTP/S. Os traces personalizados adicionados usando o SDK comportam-se normalmente se o app usar o DexGuard.
  • O plug-in com.google.firebase.firebase-perf do Gradle não é compatível com o Jack, que está obsoleto.

Integração da depuração

Você pode ativar a geração de registros de depuração para o Monitoramento de desempenho durante a criação e adicionar um elemento <meta-data> ao <application> do arquivo AndroidManifest.xml do seu app, da seguinte maneira:

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

Você pode ver o registro de solicitação de trace e rede HTTP/S usando o filtro logcat. As mensagens de registro do Monitoramento de desempenho são marcadas com FirebasePerformance e podem ser filtradas usando o seguinte comando:

adb logcat -s FirebasePerformance

Próximas etapas

Enviar comentários sobre…

Precisa de ajuda? Acesse nossa página de suporte.