Começar a usar o Firebase Crashlytics

Neste guia de início rápido, descrevemos como configurar o Firebase Crashlytics no seu app com o SDK do Firebase Crashlytics para que você receba 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ê precisará 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. Se você não tiver 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.

    • Caso seu projeto do Firebase não tenha o Google Analytics ativado, faça a ativação na guia Integrações das suas > Configurações do projeto no Console do Firebase.

    • Se estiver criando um novo projeto do Firebase, ative o Google Analytics durante o fluxo de trabalho de criação do projeto.

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 de 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 ao Crashlytics reportar 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 momento da compilação 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. Compile 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. Para isso, execute o seguinte comando 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

    • 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 no Unity: PATH/TO/SYMBOLS é o caminho do arquivo de símbolos 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 ver os dados iniciais no painel do Console do Firebase, é necessário forçar uma falha de teste.

  1. Encontre um GameObject existente e adicione-o 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 seu aplicativo estiver em execução, observe o registro do dispositivo e aguarde a exceção ser acionada a partir do CrashlyticsTester.

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

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

  4. Acesse o painel do Crashlytics no Console do Firebase para conferir a falha do teste.

    Se você atualizou o console e ainda não consegue ver a falha de teste após 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 precisa 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.
  • 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 verificar versões específicas.