Começar a usar o Firebase Crashlytics

Neste guia de início rápido, vamos mostrar como configurar o Firebase Crashlytics no seu app com o SDK do Firebase Crashlytics para receber relatórios de erros abrangentes no console do Firebase.

A configuração do Crashlytics exige tarefas no console do Firebase e no ambiente de desenvolvimento integrado, como adicionar um arquivo de configuração do Firebase e o SDK do Crashlytics. Para concluir a configuração, você terá que forçar uma falha de teste para enviar seu primeiro relatório de erros ao Firebase.

Antes de começar

1. Adicione o Firebase ao seu projeto do Unity, caso ainda não tenha feito isso. Caso você não tenha um projeto do Unity, faça o download de um app de exemplo.

2. Recomendado: para gerar automaticamente registros de navegação estrutural e entender as ações do usuário que levam a uma falha, um evento não fatal ou um ANR, você precisa para ativar o Google Analytics no seu projeto do Firebase.

   • Se o Google Analytics não estiver ativado no seu projeto do Firebase, ative o Google Analytics na guia Integrações das suas settings > Configurações do projeto no console do Firebase.

   • Se você estiver criando um novo projeto do Firebase, ative o Google Analytics durante a criação.

Etapa 1: adicionar o SDK do Crashlytics ao seu app

Quando você registrou seu projeto do Unity no projeto do Firebase, talvez já tenha feito o download do SDK do Firebase para Unity e adicionado os pacotes descritos nas etapas a seguir.

1. Faça o download do SDK do Firebase para Unity e descompacte o SDK em um local prático. O SDK do Firebase para Unity não é específico para nenhuma plataforma.

2. No seu projeto aberto do Unity, acesse Assets > Import Package > Custom Package.

3. No SDK descompactado, selecione a opção para importar o SDK do Crashlytics (FirebaseCrashlytics.unitypackage).

   Para aproveitar os registros de navegação estrutural, adicione também o SDK do Firebase para Google Analytics ao seu app (FirebaseAnalytics.unitypackage). Verifique se o Google Analytics está ativado no seu projeto do Firebase.

4. Na janela Import Unity Package, clique em Import.

Etapa 2: inicializar o Crashlytics

1. Crie um novo script em C# e adicione-o a um GameObject no cenário.

   1. Abra seu primeiro cenário e crie um GameObject em branco chamado CrashlyticsInitializer.

   2. Clique em Adicionar componente no Inspetor para o novo objeto.

   3. Selecione seu script CrashlyticsInit para adicioná-lo ao objeto CrashlyticsInitializer.

2. Inicialize o Crashlytics no método Start do script:

   using System.Collections;
   using System.Collections.Generic;
   using UnityEngine;
   
   // Import Firebase and Crashlytics
   using Firebase;
   using Firebase.Crashlytics;
   
   public class CrashlyticsInit : MonoBehaviour {
       // Use this for initialization
       void Start () {
           // Initialize Firebase
           Firebase.FirebaseApp.CheckAndFixDependenciesAsync().ContinueWith(task => {
               var dependencyStatus = task.Result;
               if (dependencyStatus == Firebase.DependencyStatus.Available)
               {
                   // Create and hold a reference to your FirebaseApp,
                   // where app is a Firebase.FirebaseApp property of your application class.
                   // Crashlytics will use the DefaultInstance, as well;
                   // this ensures that Crashlytics is initialized.
                   Firebase.FirebaseApp app = Firebase.FirebaseApp.DefaultInstance;
   
                   // When this property is set to true, Crashlytics will report all
                   // uncaught exceptions as fatal events. This is the recommended behavior.
                   Crashlytics.ReportUncaughtExceptionsAsFatal = true;
   
                   // Set a flag here for indicating that your project is ready to use Firebase.
               }
               else
               {
                   UnityEngine.Debug.LogError(System.String.Format(
                     "Could not resolve all Firebase dependencies: {0}",dependencyStatus));
                   // Firebase Unity SDK is not safe to use here.
               }
           });
       }
   
     // Update is called once per frame
     void Update()
       // ...
   }

Etapa 3: (somente Android) configurar o upload de símbolos

Essa etapa só é necessária para apps Android que usam IL2CPP.

• Essas etapas não são necessárias para apps Android que usam o back-end de script Mono do Unity.

• Essas etapas não são necessárias para apps da plataforma Apple porque o plug-in do Editor do Firebase para Unity configura automaticamente o projeto Xcode para fazer upload dos símbolos.

O SDK 8.6.1+ do Crashlytics para Unity inclui automaticamente os relatórios de erros do NDK, que permitem que o Crashlytics reporte automaticamente as falhas do IL2CPP do Unity no Android. No entanto, para ver stack traces simbolizados para falhas da biblioteca nativa no painel do Crashlytics, faça upload das informações de símbolos no tempo de build usando a CLI do Firebase.

Para configurar o upload de símbolos, siga as instruções para instalar a CLI do Firebase.

Se você já instalou a CLI, atualize-a para a versão mais recente.

Etapa 4: criar seu projeto e fazer upload de símbolos

iOS+ (plataforma Apple)

1. Na caixa de diálogo Build Settings, exporte seu projeto para um espaço de trabalho do Xcode.

2. Crie seu app.

   Para plataformas Apple, o plug-in do Editor do Firebase para Unity configura automaticamente seu projeto do Xcode para gerar e fazer upload de um arquivo de símbolos compatível com o Crashlytics para os servidores do Firebase em cada build.

Android

1. Na caixa de diálogo Build Settings, siga um destes procedimentos:

   • Exporte para o Android Studio para criar seu projeto ou

   • Crie seu APK diretamente no Editor do Unity.
     Antes de começar a criar, verifique se a caixa de seleção Create symbols.zip está marcada na caixa de diálogo Build Settings.

2. Quando o build estiver concluído, gere um arquivo de símbolos compatível com o Crashlytics e faça upload dele para os servidores do Firebase executando o comando a seguir na CLI do Firebase:

   firebase crashlytics:symbols:upload --app=FIREBASE_APP_ID PATH/TO/SYMBOLS

   • FIREBASE_APP_ID: seu ID do app Android do Firebase (não o nome do pacote)
     Exemplo de ID do app Android do Firebase: 1:567383003300:android:17104a2ced0c9b9b

     Precisa encontrar o ID do app Firebase?

     Veja duas maneiras de encontrar o ID do app Firebase:

     • No arquivo google-services.json, o ID do app é o valor mobilesdk_app_id; ou

     • No console do Firebase, acesse as Configurações do projeto. Role a tela para baixo até o card Seus apps e clique no app Firebase que você quer para encontrar o ID respectivo.

   • PATH/TO/SYMBOLS: o caminho para o arquivo de símbolos gerado pela CLI

     • Exportado para um projeto do Android Studio: PATH/TO/SYMBOLS é o diretório unityLibrary/symbols, que é criado na raiz do projeto exportado depois que você compila o app usando o Gradle ou o Android Studio.

     • Crie o APK diretamente do Unity: PATH/TO/SYMBOLS é o caminho do arquivo de símbolo compactado, gerado no diretório raiz do projeto quando o build foi concluído (por exemplo: myproject/myapp-1.0-v100.symbols.zip).

   Veja opções avançadas para usar o comando da CLI do Firebase para gerar e fazer upload de arquivos de símbolos

   Flag	Descrição
   --generator=csym	Usa o gerador de arquivos de símbolo legado do cSYM em vez do gerador padrão do Breakpad. Não recomendado. Recomendamos o uso do gerador de arquivos de símbolo padrão do Breakpad.
   --generator=breakpad	Usa o gerador de arquivos de símbolo do Breakpad O padrão para a geração de arquivos de símbolo é o Breakpad. Use essa sinalização apenas se você tiver adicionado symbolGenerator { csym() } à configuração do build e quiser substitui-la para utilizar o Breakpad.
   --dry-run	Gera os arquivos de símbolo, mas não faz upload deles Essa sinalização é útil se você quiser inspecionar o conteúdo dos arquivos enviados.
   --debug	Fornece informações de depuração adicionais

Etapa 5: forçar uma falha no teste para concluir a configuração

Para concluir a configuração do Crashlytics e conferir os dados iniciais no painel do Crashlytics no console do Firebase, é necessário forçar uma falha de teste.

1. Encontre um GameObject já criado e o adicione ao script a seguir. Esse script causa uma falha no teste alguns segundos depois da execução do app.

   using System;
   using UnityEngine;
   
   public class CrashlyticsTester : MonoBehaviour {
   
       int updatesBeforeException;
   
       // Use this for initialization
       void Start () {
         updatesBeforeException = 0;
       }
   
       // Update is called once per frame
       void Update()
       {
           // Call the exception-throwing method here so that it's run
           // every frame update
           throwExceptionEvery60Updates();
       }
   
       // A method that tests your Crashlytics implementation by throwing an
       // exception every 60 frame updates. You should see reports in the
       // Firebase console a few minutes after running your app with this method.
       void throwExceptionEvery60Updates()
       {
           if (updatesBeforeException > 0)
           {
               updatesBeforeException--;
           }
           else
           {
               // Set the counter to 60 updates
               updatesBeforeException = 60;
   
               // Throw an exception to test your Crashlytics implementation
               throw new System.Exception("test exception please ignore");
           }
       }
   }

2. Crie seu app e, em seguida, faça upload das informações de símbolo.

   • iOS+: o plug-in do Editor do Firebase para Unity configura automaticamente seu projeto do Xcode para fazer upload do arquivo de símbolo.

   • Android: para apps Android que usam IL2CPP, execute o comando crashlytics:symbols:upload da CLI do Firebase para fazer upload do seu arquivo de símbolo.

3. Execute o app. Quando ele estiver em execução, observe o registro do dispositivo e espere a exceção ser acionada pelo CrashlyticsTester.

   • iOS+: confira os registros no painel da parte de baixo do Xcode.

   • Android: veja os registros executando o comando adb logcat no terminal.

4. Acesse o painel do Crashlytics no console do Firebase para ver a falha do teste.

   Se você já atualizou o console e ainda não está vendo a falha de teste depois de cinco minutos, ative a geração de registros de depuração para ver se o app está enviando relatórios de falha.

Pronto. O Crashlytics está monitorando seu app em busca de falhas. Acesse o painel do Crashlytics para ver e analisar todos os relatórios e estatísticas.

Próximas etapas

• (Recomendado) Para apps Android que usam IL2CPP, receba ajuda para depurar falhas causadas por erros de memória nativa coletando GWP-ASan relatórios. Esses erros relacionados à memória podem ser associados à corrupção da memória no seu app, que é a principal causa de vulnerabilidades de segurança. Para aproveitar esse recurso de depuração, seu app tem que usar o SDK mais recente do Crashlytics para Unity (v10.7.0+) e ter o GWP-ASan explicitamente ativado. É necessário modificar o manifesto do app Android.

• Para personalizar a configuração do relatório de erros, adicione a permissão de geração de relatórios, registros, chaves e rastreamento de erros não fatais.

• Faça a integração com o Google Play para filtrar os relatórios de erros do app Android pela faixa do Google Play diretamente no painel do Crashlytics. Isso permite que você configure o painel para monitorar builds específicos.