Personalize seus relatórios de erros do Firebase Crashlytics

Unidade de vibração iOS + Android

No painel do Crashlytics, você pode clicar em um problema e obter um relatório detalhado do evento. Você pode personalizar esses relatórios para ajudar a entender melhor o que está acontecendo no seu aplicativo e as circunstâncias dos eventos relatados ao Crashlytics.

• Instrumente seu aplicativo para registrar chaves personalizadas , mensagens de log personalizadas e identificadores de usuário .

• Relate exceções ao Crashlytics.

• Obtenha registros de localização atual automaticamente se seu aplicativo usar o SDK do Firebase para Google Analytics. Esses registros fornecem visibilidade das ações do usuário que levaram a um evento coletado pelo Crashlytics no seu aplicativo.

• Desative o relatório automático de falhas e ative o relatório opcional para seus usuários. Observe que, por padrão, o Crashlytics coleta automaticamente relatórios de erros de todos os usuários do seu aplicativo.

Adicione chaves personalizadas

As chaves personalizadas ajudam você a obter o estado específico do seu aplicativo que levou a uma falha. Você pode associar pares chave/valor arbitrários aos seus relatórios de falhas e, em seguida, usar as chaves personalizadas para pesquisar e filtrar relatórios de falhas no Console do Firebase.

• No painel do Crashlytics , você pode pesquisar problemas que correspondam a uma chave personalizada.

• Ao revisar um problema específico no console, você pode visualizar as chaves personalizadas associadas a cada evento (subguia Chaves ) e até mesmo filtrar os eventos por chaves personalizadas (menu Filtro na parte superior da página).

Observação: o Crashlytics oferece suporte a no máximo 64 pares de chave/valor. Depois de atingir esse limite, os valores adicionais não serão salvos. Cada par chave/valor pode ter até 1 KB de tamanho.

Use o método de instância setCustomKey para configurar pares chave/valor. Observe que setCustomKey está sobrecarregado para que o parâmetro value aceite qualquer argumento primitivo ou String . aqui estão alguns exemplos:

Kotlin+KTX

val crashlytics = Firebase.crashlytics
crashlytics.setCustomKeys {
    key("my_string_key", "foo") // String value
    key("my_bool_key", true) // boolean value
    key("my_double_key", 1.0) // double value
    key("my_float_key", 1.0f) // float value
    key("my_int_key", 1) // int value
}

Java

FirebaseCrashlytics crashlytics = FirebaseCrashlytics.getInstance();

crashlytics.setCustomKey("my_string_key", "foo" /* string value */);

crashlytics.setCustomKey("my_bool_key", true /* boolean value */);

crashlytics.setCustomKey("my_double_key", 1.0 /* double value */);

crashlytics.setCustomKey("my_float_key", 1.0f /* float value */);

crashlytics.setCustomKey("my_int_key", 1 /* int value */);

Você também pode modificar o valor de uma chave existente chamando a chave e definindo-a com um valor diferente. Por exemplo:

Kotlin+KTX

val crashlytics = Firebase.crashlytics
crashlytics.setCustomKeys {
    key("current_level", 3)
    key("last_UI_action", "logged_in")
}

Java

FirebaseCrashlytics crashlytics = FirebaseCrashlytics.getInstance();

crashlytics.setCustomKey("current_level", 3);
crashlytics.setCustomKey("last_UI_action", "logged_in");

Adicione pares chave/valor em massa passando uma instância de CustomKeysAndValues ​​para o método de instância setCustomKeys :

Kotlin+KTX

Para Kotlin, a funcionalidade existente é mais simples do que usar o construtor CustomKeysAndValues .

crashlytics.setCustomKeys {
  key("str_key", "hello")
  key("bool_key", true)
  key("int_key", 1)
  key("long_key", 1L)
  key("float_key", 1.0f)
  key("double_key", 1.0)
}

Java

CustomKeysAndValues keysAndValues = new CustomKeysAndValues.Builder()
.putString("string key", "string value")
.putString("string key 2", "string  value 2")
.putBoolean("boolean key", True)
.putBoolean("boolean key 2", False)
.putFloat("float key", 1.01)
.putFloat("float key 2", 2.02)
.build();

FirebaseCrashlytics.getInstance().setCustomKeys(keysAndValues);

Adicione mensagens de log personalizadas

Para ter mais contexto sobre os eventos que levaram a uma falha, você pode adicionar registros personalizados do Crashlytics ao seu aplicativo. O Crashlytics associa os registros aos dados de falhas e os exibe na página Crashlytics do console do Firebase , na guia Logs .

Observação: para evitar lentidão no aplicativo, o Crashlytics limita os registros a 64 KB e exclui entradas de registro mais antigas quando os registros de uma sessão ultrapassam esse limite.

Use log para ajudar a identificar problemas. Por exemplo:

Kotlin+KTX

Firebase.crashlytics.log("message")

Java

FirebaseCrashlytics.getInstance().log("message");

Definir identificadores de usuário

Para diagnosticar um problema, muitas vezes é útil saber quais dos seus usuários sofreram uma determinada falha. O Crashlytics inclui uma maneira de identificar usuários anonimamente em seus relatórios de falhas.

Para adicionar IDs de usuário aos seus relatórios, atribua a cada usuário um identificador exclusivo na forma de um número de ID, token ou valor com hash:

Kotlin+KTX

Firebase.crashlytics.setUserId("user123456789")

Java

FirebaseCrashlytics.getInstance().setUserId("user123456789");

Se você precisar limpar um identificador de usuário depois de defini-lo, redefina o valor para uma sequência em branco. Limpar um identificador de usuário não remove os registros existentes do Crashlytics. Se você precisar excluir registros associados a um ID de usuário, entre em contato com o suporte do Firebase .

(Somente Android NDK) Adicionar metadados aos relatórios de erros do NDK

Opcionalmente, você pode incluir o cabeçalho crashlytics.h em seu código C++ para adicionar metadados aos relatórios de falhas do NDK, como chaves personalizadas , logs personalizados e identificadores de usuário . Todas essas opções estão descritas nesta página acima.

crashlytics.h está disponível como uma biblioteca C++ somente de cabeçalho no repositório GitHub do Firebase Android SDK .

Leia os comentários no arquivo de cabeçalho para obter instruções sobre como usar as APIs C++ do NDK.

Incluir relatórios GWP-ASan para depurar problemas de corrupção de memória

O Crashlytics pode ajudá-lo a depurar falhas causadas por erros de memória nativa coletando relatórios GWP-ASan. Esses erros relacionados à memória podem estar associados à corrupção de memória do seu aplicativo, que é a principal causa de vulnerabilidades de segurança do aplicativo.

• Você pode visualizar esses dados em uma nova guia "Rastreamentos de pilha de memória" ao clicar nos detalhes de um problema no painel do Crashlytics .

• Você também pode usar o novo sinal e filtro "Relatório GWP-ASan" para visualizar rapidamente todos os problemas com esses dados.

Você pode obter relatórios de memória do GWP-ASan se ativar explicitamente o GWP-ASan no seu aplicativo e usar o SDK do Crashlytics para NDK v18.3.6+ (Firebase BoM v31.3.0+). Você pode testar a configuração do GWP-ASan usando o código nativo de exemplo na documentação do Android .

Relatar exceções não fatais

Além de relatar automaticamente as falhas do seu aplicativo, o Crashlytics permite registrar exceções não fatais e enviá-las para você na próxima vez que o aplicativo for iniciado.

Observação: o Crashlytics armazena apenas as oito exceções registradas mais recentes. Se seu aplicativo gerar mais de oito exceções, as exceções mais antigas serão perdidas.

Use o método recordException para registrar exceções não fatais nos blocos catch do seu aplicativo. Por exemplo:

Kotlin+KTX

try {
    methodThatThrows()
} catch (e: Exception) {
    Firebase.crashlytics.recordException(e)
    // handle your exception here
}

Java

try {
    methodThatThrows();
} catch (Exception e) {
    FirebaseCrashlytics.getInstance().recordException(e);
    // handle your exception here
}

Aviso: se desejar incluir um valor exclusivo (por exemplo, um ID de usuário ou um carimbo de data/hora) em sua mensagem de exceção, use uma chave personalizada em vez de adicionar o valor diretamente na mensagem de exceção. Adicionar valores diretamente pode resultar em vários problemas e fazer com que o Crashlytics limite os erros de relatório no seu aplicativo.

Todas as exceções registradas aparecem como problemas não fatais no console do Firebase. O resumo do problema contém todas as informações de estado que você normalmente obtém de travamentos, além de detalhamentos por versão do Android e dispositivo de hardware.

O Crashlytics processa exceções em um thread de segundo plano dedicado para minimizar o impacto no desempenho do seu aplicativo. Para reduzir o tráfego de rede dos seus usuários, o Crashlytics agrupa exceções registradas em lote e as envia na próxima vez que o aplicativo for iniciado.

Obtenha registros de localização atual

Os registros de localização atual fornecem uma melhor compreensão das interações que um usuário teve com seu aplicativo, levando a um evento de falha, não fatal ou ANR. Esses logs podem ser úteis ao tentar reproduzir e depurar um problema.

Os registros de navegação estrutural são desenvolvidos pelo Google Analytics. Portanto, para obtê-los, você precisa ativar o Google Analytics para seu projeto do Firebase e adicionar o SDK do Firebase para Google Analytics ao seu aplicativo. Depois que esses requisitos forem atendidos, os logs de navegação serão automaticamente incluídos nos dados de um evento na guia Logs quando você visualizar os detalhes de um problema.

O SDK do Analytics registra automaticamente o evento screen_view , que permite que os registros de localização atual mostrem uma lista de telas visualizadas antes do evento de falha, não fatal ou ANR. Um log de localização atual screen_view contém um parâmetro firebase_screen_class .

Os logs de localização atual também são preenchidos com quaisquer eventos personalizados registrados manualmente na sessão do usuário, incluindo os dados de parâmetro do evento. Esses dados podem ajudar a mostrar uma série de ações do usuário que levam a um evento de falha, não fatal ou ANR.

Observe que você pode controlar a coleta e o uso de dados do Google Analytics , que incluem os dados que preenchem os registros de localização atual.

Ativar relatórios de aceitação

Por padrão, o Crashlytics coleta automaticamente relatórios de erros de todos os usuários do seu aplicativo. Para dar aos usuários mais controle sobre os dados que enviam, você pode ativar os relatórios de aceitação desativando os relatórios automáticos e enviando dados ao Crashlytics apenas quando desejar em seu código:

1. No bloco de application do arquivo AndroidManifest.xml , adicione uma tag meta-data para desativar a coleta automática:

   <meta-data
       android:name="firebase_crashlytics_collection_enabled"
       android:value="false" />
   

2. Habilite a coleta para usuários selecionados chamando a substituição da coleta de dados do Crashlytics em tempo de execução. O valor de substituição persiste durante as inicializações do seu aplicativo para que o Crashlytics possa coletar relatórios automaticamente. Para cancelar o relatório automático de falhas, passe false como o valor de substituição. Quando definido como false , o novo valor não se aplica até a próxima execução do aplicativo.

   Kotlin+KTX

   Firebase.crashlytics.setCrashlyticsCollectionEnabled(true)

   Java

   FirebaseCrashlytics.getInstance().setCrashlyticsCollectionEnabled(true);

Observação: quando a coleta de dados estiver desativada, o Crashlytics armazenará informações de falhas localmente no dispositivo. Se a coleta de dados for ativada posteriormente, qualquer informação de falha armazenada no dispositivo será enviada ao Crashlytics para processamento.

Gerenciar dados do Crash Insights

O Crash Insights ajuda a resolver problemas comparando seus rastreamentos de pilha anônimos com rastreamentos de outros aplicativos do Firebase e informando se o problema faz parte de uma tendência maior. Para muitos problemas, o Crash Insights ainda fornece recursos para ajudá-lo a depurar a falha.

Crash Insights usa dados agregados de falhas para identificar tendências comuns de estabilidade. Se preferir não compartilhar os dados do seu aplicativo, você pode desativar o Crash Insights no menu Crash Insights, na parte superior da lista de problemas do Crashlytics no console do Firebase .

Observação: desabilitar o compartilhamento de dados também remove insights sobre seus problemas. As alterações podem levar até 24 horas para entrar em vigor.