Catch up on everything announced at Firebase Summit, and learn how Firebase can help you accelerate app development and run your app with confidence. Learn More

Personalize seus relatórios de falhas do Firebase Crashlytics

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

Este guia descreve como personalizar seus relatórios de falhas usando as APIs do Crashlytics. Por padrão, o Crashlytics coleta automaticamente relatórios de falhas nativos da plataforma para todos os usuários do seu aplicativo (você também pode desativar os relatórios automáticos de falhas e habilitar relatórios opcionais para seus usuários). O Crashlytics fornece cinco mecanismos de registro prontos para uso: chaves personalizadas , registros personalizados , identificadores de usuário , exceções capturadas e não capturadas.

Para aplicativos Flutter, os relatórios fatais são enviados ao Crashlytics em tempo real sem a necessidade de o usuário reiniciar o aplicativo. Os relatórios não fatais são gravados no disco para serem enviados junto com o próximo relatório fatal ou quando o aplicativo for reiniciado.

Relatar exceções não detectadas

Você pode detectar automaticamente todos os erros "fatais" gerados na estrutura do Flutter substituindo FlutterError.onError por FirebaseCrashlytics.instance.recordFlutterFatalError . Como alternativa, para capturar também exceções "não fatais", substitua FlutterError.onError por FirebaseCrashlytics.instance.recordFlutterError :

void main() async {
  WidgetsFlutterBinding.ensureInitialized();

  await Firebase.initializeApp();
  bool weWantFatalErrorRecording = true;
  FlutterError.onError = (errorDetails) {
    if(weWantFatalErrorRecording){
      FirebaseCrashlytics.instance.recordFlutterFatalError(errorDetails);
    } else {
      FirebaseCrashlytics.instance.recordFlutterError(errorDetails);
    }
  };

  runApp(MyApp());
}

Erros assíncronos

Erros assíncronos não são detectados pelo framework Flutter:

ElevatedButton(
  onPressed: () async {
    throw Error();
  }
  ...
)

Para detectar esses erros, você pode usar o manipulador PlatformDispatcher.instance.onError :

Future<void> main() async {
    WidgetsFlutterBinding.ensureInitialized();
    await Firebase.initializeApp();
    FlutterError.onError = (errorDetails) {
      FirebaseCrashlytics.instance.recordFlutterFatalError(errorDetails);
    };
    // Pass all uncaught asynchronous errors that aren't handled by the Flutter framework to Crashlytics
    PlatformDispatcher.instance.onError = (error, stack) {
      FirebaseCrashlytics.instance.recordError(error, stack, fatal: true);
      return true;
    };
    runApp(MyApp());

}

Erros fora do Flutter

Para detectar erros que acontecem fora do contexto do Flutter, instale um ouvinte de erro no Isolate atual:

Isolate.current.addErrorListener(RawReceivePort((pair) async {
  final List<dynamic> errorAndStacktrace = pair;
  await FirebaseCrashlytics.instance.recordError(
    errorAndStacktrace.first,
    errorAndStacktrace.last,
    fatal: true,
  );
}).sendPort);

Relatar exceções capturadas

Além de relatar automaticamente as falhas do seu aplicativo, o Crashlytics permite que você registre exceções não fatais e as envie para você na próxima vez que um evento fatal for relatado ou quando o aplicativo for reiniciado.

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

await FirebaseCrashlytics.instance.recordError(
  error,
  stackTrace,
  reason: 'a non-fatal error'
);

// Or you can use:
await FirebaseCrashlytics.instance.recordFlutterError(errorDetails);

Você também pode registrar mais informações sobre o erro, o que é possível usando a propriedade information :

await FirebaseCrashlytics.instance.recordError(
  error,
  stackTrace,
  reason: 'a non-fatal error',
  information: ['further diagnostic information about the error', 'version 2.0'],
);

Essas exceções 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, juntamente com avarias por versão 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 usuários, o Crashlytics limitará a taxa do número de relatórios enviados do dispositivo, se necessário.

Adicionar chaves personalizadas

As chaves personalizadas ajudam você a obter o estado específico do seu aplicativo que leva a uma falha. Você pode associar pares de chave/valor arbitrários a seus relatórios de travamento e, em seguida, usar as chaves personalizadas para pesquisar e filtrar relatórios de travamento 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).

Use o método de instância setCustomKey para definir pares chave/valor. aqui estão alguns exemplos:

// Set a key to a string.
FirebaseCrashlytics.instance.setCustomKey('str_key', 'hello');

// Set a key to a boolean.
FirebaseCrashlytics.instance.setCustomKey("bool_key", true);

// Set a key to an int.
FirebaseCrashlytics.instance.setCustomKey("int_key", 1);

// Set a key to a long.
FirebaseCrashlytics.instance.setCustomKey("int_key", 1L);

// Set a key to a float.
FirebaseCrashlytics.instance.setCustomKey("float_key", 1.0f);

// Set a key to a double.
FirebaseCrashlytics.instance.setCustomKey("double_key", 1.0);

Adicionar mensagens de registro personalizadas

Para obter mais contexto para os eventos que levaram a uma falha, você pode adicionar logs personalizados do Crashlytics ao seu aplicativo. O Crashlytics associa os logs aos seus dados de travamento e os exibe no console do Firebase , na guia Logs do Crashlytics.

Use log para ajudar a identificar problemas. Por exemplo:

FirebaseCrashlytics.instance.log("Higgs-Boson detected! Bailing out");

Definir identificadores de usuário

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

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

FirebaseCrashlytics.instance.setUserIdentifier("12345");

Se você precisar limpar um identificador de usuário depois de defini-lo, redefina o valor para uma string em branco. A limpeza de 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 .

Ativar relatório de ativação

Por padrão, o Crashlytics coleta automaticamente relatórios de falhas para todos os usuários do seu aplicativo. Para dar aos usuários mais controle sobre os dados que eles enviam, você pode habilitar relatórios opcionais desativando os relatórios automáticos e enviando dados apenas para o Crashlytics quando você escolher em seu código:

  1. Desative a coleta automática nativamente:

    Plataformas da Apple

    Adicione uma nova chave ao seu arquivo Info.plist :

    • Chave: FirebaseCrashlyticsCollectionEnabled
    • Valor: false

    Android

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

    <meta-data
        android:name="firebase_crashlytics_collection_enabled"
        android:value="false" />
    
  2. Ative a coleta para usuários selecionados chamando a substituição da coleta de dados do Crashlytics no tempo de execução.

    O valor de substituição persiste nas inicializações do seu aplicativo para que o Crashlytics possa coletar relatórios automaticamente. Para desativar o relatório de travamento automático, 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.

    FirebaseCrashlytics.instance.setCrashlyticsCollectionEnabled(true);
    

Gerenciar dados do Crash Insights

O Crash Insights ajuda você a resolver problemas comparando seus rastreamentos de pilha anônimos com os 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 o travamento.

O Crash Insights usa dados de falhas agregados 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 .