Personalizar relatórios de erros do Firebase Crashlytics

Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

No painel do Crashlytics, clique em um problema e acesse um relatório de eventos detalhado. É possível personalizar esses relatórios para entender melhor o que está acontecendo no app e as circunstâncias em torno dos eventos informados ao Crashlytics.

• Instrumente o app para registrar chaves personalizadas, mensagens de registro personalizadas e identificadores de usuários.

• Informe exceções ao Crashlytics.

• Receba automaticamente registros de navegação estrutural se o app usar o SDK do Firebase para Google Analytics. Com eles, é possível visualizar as ações do usuário antes de um evento coletado pelo Crashlytics no seu app.

• Desative a geração automática de relatórios de falhas e ative a permissão para geração de relatórios para seus usuários. Por padrão, o Crashlytics coleta automaticamente relatórios de erros para todos os usuários do seu app.

Adicionar chaves personalizadas

As chaves personalizadas ajudam você a saber o estado específico do seu app antes de uma falha. É possível associar pares de chave-valor arbitrários aos seus relatórios de erros e usar as chaves personalizadas para pesquisar e filtrar relatórios de erros no console do Firebase.

• No painel do Crashlytics, é possível pesquisar problemas que correspondam a uma chave personalizada.

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

Use o método de instância setCustomKey para definir pares de chave-valor. Observe que setCustomKey está sobrecarregado para o parâmetro value para aceitar qualquer argumento primitivo ou String. Veja alguns exemplos:

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
}

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 */);

Para modificar o valor de uma chave atual, chame a chave e defina-a com um valor diferente. Por exemplo:

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

FirebaseCrashlytics crashlytics = FirebaseCrashlytics.getInstance();

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

Adicione pares de chave-valor em massa transmitindo uma instância de CustomKeysAndValues para o método de instância setCustomKeys:

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

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

Adicionar mensagens de registro personalizadas

Para contextualizar melhor os eventos antes de uma falha, adicione registros personalizados do Crashlytics ao seu app. O Crashlytics associa os registros aos dados de falhas e os exibe na página do Crashlytics no console do Firebase, na guia Registros.

Use log para identificar problemas. Por exemplo:

Firebase.crashlytics.log("message")

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

Definir identificadores de usuários

Para diagnosticar um problema, é útil identificar os usuários que observaram uma determinada falha. O Crashlytics inclui uma maneira de identificar anonimamente os usuários nos relatórios de erros.

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

Firebase.crashlytics.setUserId("user123456789")

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

Para apagar um identificador de usuário depois de configurá-lo, redefina o valor deixando uma string em branco. Limpar um identificador de usuário não remove os registros vigentes do Crashlytics. Para excluir registros associados a um ID do usuário, entre em contato com o suporte do Firebase.

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

Como opção, é possível incluir o cabeçalho crashlytics.h no código em C++ para adicionar metadados aos relatórios de erros do NDK, como chaves personalizadas, registros personalizados e identificadores de usuários. Todas essas opções estão descritas nesta página acima.

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

Leia os comentários no arquivo de cabeçalho para saber como usar as APIs de C++ do NDK.

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

O Crashlytics pode ajudar a depurar falhas causadas por erros de memória nativa coletando relatórios do GWP-ASan. Os erros relacionados à memória podem ser associados à corrupção da memória no seu app, que é a principal causa de vulnerabilidades de segurança.

• Esses dados podem ser visualizados em uma nova guia Stack traces da memória quando você clica nos detalhes de um problema no painel do Crashlytics.

• Também é possível usar o novo sinal Relatório do GWP-Asan e filtrar para ter acesso rápido a todos os problemas dos dados.

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

Relatar exceções não fatais

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

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

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

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

Além disso, você também pode anexar chaves personalizadas à exceção não fatal específica. Por exemplo:

try {
    methodThatThrows()
} catch (e: Exception) {
    Firebase.crashlytics.recordException(e) {
        key("string key", "string value")
        key("boolean key", true)
        key("float key", Float.MAX_VALUE)
    }
    // handle your exception here
}

try {
    methodThatThrows();
} catch (Exception e) {
    CustomKeysAndValues keysAndValues = new CustomKeysAndValues.Builder()
            .putString("string key", "string value")
            .putBoolean("boolean key", true)
            .putFloat("float key", Float.MAX_VALUE)
            .build();
    FirebaseCrashlytics.getInstance().recordException(e, keysAndValues);
    // handle your exception here
}

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ê geralmente recebe com as falhas, além de detalhamentos por versão do Android e dispositivo de hardware.

O Crashlytics processa exceções em uma linha de execução dedicada em segundo plano para minimizar o impacto no desempenho do app. Para reduzir o tráfego de rede dos usuários, o Crashlytics agrupa exceções registradas e as envia na próxima vez que o app é iniciado.

Acessar registros de navegação estrutural

Os registros de navegação estrutural oferecem uma melhor compreensão das interações de um usuário com seu app que levaram a um evento não fatal, de falha ou de ANR. Esses registros podem ser úteis ao tentar reproduzir e depurar um problema.

Os registros de navegação estrutural usam a tecnologia do Google Analytics. Para receber esses registros, ative o Google Analytics no seu projeto do Firebase e adicione o SDK do Firebase para Google Analytics ao seu app. Quando esses requisitos forem atendidos, os registros de navegação estrutural serão incluídos automaticamente com os dados de um evento na guia Registros quando você visualizar os detalhes de um problema.

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

Os registros de navegação estrutural também são preenchidos com todos os 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 antes de um evento não fatal, de falha ou de ANR.

É possível controlar a coleta e o uso de dados do Google Analytics, o que inclui os dados que preenchem os registros de navegação estrutural.

Ativar a permissão para geração de relatórios

Por padrão, o Crashlytics coleta automaticamente relatórios de erros para todos os usuários do seu app. Para dar aos usuários mais controle sobre os dados que são enviados, ative a permissão para geração de relatórios. Para fazer isso, basta desativar a criação automática de relatórios e só enviar dados ao Crashlytics quando você quiser no seu código

1. No bloco 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. Para ativar a coleta dos usuários selecionados, chame a modificação da coleta de dados do Crashlytics no ambiente de execução. O valor de substituição persiste em todos os lançamentos subsequentes do app. Dessa forma, o Crashlytics pode coletar relatórios automaticamente para esse usuário.

   Kotlin

   Firebase.crashlytics.setCrashlyticsCollectionEnabled(true)

   Java

   FirebaseCrashlytics.getInstance().setCrashlyticsCollectionEnabled(true);

   Se o usuário desativar a coleta de dados mais tarde, você poderá transmitir false como o valor de substituição, que será aplicado na próxima vez que o usuário iniciar o app e permanecerá em todos os lançamentos subsequentes para esse usuário.

Gerenciar dados do Crash Insights

Com o Crash Insights, você soluciona problemas quando compara stack traces anônimos a traces de outros aplicativos do Firebase. Você receberá um aviso se o problema fizer parte de uma tendência maior. Para muitos problemas, o Crash Insights também oferece recursos para ajudar a depurar a falha.

Ele usa dados de falhas agregados para identificar tendências de estabilidade comuns. Caso prefira não compartilhar os dados do app, é possível desativar o Crash Insights no menu com o mesmo nome na parte de cima da lista de problemas do Crashlytics no console do Firebase.