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

Adicione o Firebase ao seu projeto da Apple caso ainda não tenha feito isso. Caso você não tenha um app da Apple, faça o download de um app de exemplo.
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 > 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.
Os registros de navegação estrutural estão disponíveis para todas as plataformas da Apple compatíveis com o Crashlytics, exceto o watchOS.

Etapa 1: adicionar o SDK do Crashlytics ao seu app

Use o Gerenciador de pacotes do Swift para instalar e gerenciar as dependências do Firebase.

No Xcode, com seu projeto do app aberto, navegue até File > Add Packages.
Quando solicitado, adicione o repositório do SDK do Firebase para as plataformas Apple:

  https://github.com/firebase/firebase-ios-sdk.git

Escolha a biblioteca do Crashlytics.
Para aproveitar os registros de navegação estrutural, adicione também o SDK do Firebase para Google Analytics ao seu app. Verifique se o Google Analytics está ativado no seu projeto do Firebase.
Adicione a flag -ObjC à seção Outras flag do vinculador das configurações de build do destino.
(Apenas macOS) Em Info.plist, adicione a chave NSApplicationCrashOnExceptions e a defina como YES.
Quando terminar, o Xcode vai começar a resolver e fazer o download das dependências em segundo plano automaticamente.

Em seguida, configure o módulo do Firebase:

Importe o módulo do Firebase no struct App ou em UIApplicationDelegate:
Swift
```
import Firebase
```
Objective-C
```
@import Firebase;
```
Configure uma instância compartilhada FirebaseApp, normalmente no método application(_:didFinishLaunchingWithOptions:) do delegado do seu app:
Swift
```
// Use the Firebase library to configure APIs.
FirebaseApp.configure()
```
Objective-C
```
// Use the Firebase library to configure APIs.
[FIRApp configure];
```

Etapa 2: configurar o Xcode para fazer upload de arquivos dSYM automaticamente

Para gerar relatórios de erros legíveis, o Crashlytics precisa dos arquivos de símbolo de depuração (dSYM, na sigla em inglês) do seu projeto. As etapas a seguir mostram como configurar o Xcode para produzir automaticamente os dSYMs, processá-los e fazer upload dos arquivos sempre que você criar um app.

Abra o espaço de trabalho do Xcode e selecione o arquivo do projeto no navegador à esquerda.
Na lista TARGETS, selecione o destino de criação principal.
Clique na guia Build Settings e conclua as etapas a seguir para que o Xcode gere dSYMs para seus builds.
1. Clique em All e pesquise por debug information format.
2. Defina Debug Information Format como DWARF with dSYM File para todos os tipos de build.
Clique na guia Build Phases e conclua as etapas a seguir para que o Xcode possa processar seus dSYMs e fazer upload dos arquivos.
1. Clique em > New Run Script Phase.
  
  Verifique se a nova fase Run Script é a última fase do build do seu projeto. Caso contrário, o Crashlytics não vai processar dSYMs corretamente.
2. Expanda a nova seção Run Script.
  
  Observação: para as subetapas restantes, copie e cole os caminhos exatamente como especificado para que o Xcode resolva esses caminhos. No entanto, se você tiver problemas com o Xcode ao resolver esses caminhos ou em uma estrutura de projeto exclusiva, especifique os caminhos manualmente.
3. No campo do script (localizado no rótulo Shell), adicione o script de execução a seguir.
  
  Este script processa os arquivos dSYM do seu projeto e faz upload deles para o Crashlytics.
```
"${BUILD_DIR%/Build/*}/SourcePackages/checkouts/firebase-ios-sdk/Crashlytics/run"
```
4. Na seção Input Files, adicione os caminhos para os locais dos arquivos a seguir:
```
${DWARF_DSYM_FOLDER_PATH}/${DWARF_DSYM_FILE_NAME}
```
```
${DWARF_DSYM_FOLDER_PATH}/${DWARF_DSYM_FILE_NAME}/Contents/Resources/DWARF/${PRODUCT_NAME}
```
```
${DWARF_DSYM_FOLDER_PATH}/${DWARF_DSYM_FILE_NAME}/Contents/Info.plist
```
```
$(TARGET_BUILD_DIR)/$(UNLOCALIZED_RESOURCES_FOLDER_PATH)/GoogleService-Info.plist
```
```
$(TARGET_BUILD_DIR)/$(EXECUTABLE_PATH)
```
  Entenda por que os locais desses arquivos são necessários
  
  O Xcode procura nos locais especificados por esses arquivos de entrada para garantir que os arquivos de build estejam disponíveis para o script de execução. Além disso, se User Script Sandboxing estiver ativado, o Xcode só vai permitir que o script de execução acesse arquivos especificados em Input Files.
  - Fornecer a localização dos arquivos dSYM do seu projeto permite que o Crashlytics processe dSYMs.
  - Fornecer a localização do arquivo GoogleService-Info.plist de build do seu app permite que o Crashlytics associe os dSYMs ao seu app do Firebase.
  - Fornecer a localização do executável do seu app permite que o script de execução impeça uploads duplicados do mesmo dSYM. Os binários do app não são enviados.

Para informações mais detalhadas sobre os arquivos dSYM e o Crashlytics (incluindo como fazer upload manual de arquivos dSYM), acesse Receber relatórios de erros desofuscados.

Etapa 3: forçar uma falha de 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.

Adicione um código ao app que possa ser usado para forçar uma falha no teste.

É possível usar o código a seguir para adicionar um botão ao seu app que, quando pressionado, causa uma falha. O botão é chamado de "Testar falha".

SwiftUI

Button("Crash") {
  fatalError("Crash was triggered")
}

UIKit

Swift

import UIKit

class ViewController: UIViewController {
  override func viewDidLoad() {
      super.viewDidLoad()

      // Do any additional setup after loading the view, typically from a nib.

      let button = UIButton(type: .roundedRect)
      button.frame = CGRect(x: 20, y: 50, width: 100, height: 30)
      button.setTitle("Test Crash", for: [])
      button.addTarget(self, action: #selector(self.crashButtonTapped(_:)), for: .touchUpInside)
      view.addSubview(button)
  }

  @IBAction func crashButtonTapped(_ sender: AnyObject) {
      let numbers = [0]
      let _ = numbers[1]
  }
}

Objective-C

#import "ViewController.h"

@implementation ViewController
‐ (void)viewDidLoad {
    [super viewDidLoad];

    // Do any additional setup after loading the view, typically from a nib.

    UIButton* button = [UIButton buttonWithType:UIButtonTypeRoundedRect];
    button.frame = CGRectMake(20, 50, 100, 30);
    [button setTitle:@"Test Crash" forState:UIControlStateNormal];
    [button addTarget:self action:@selector(crashButtonTapped:)
        forControlEvents:UIControlEventTouchUpInside];
    [self.view addSubview:button];
}

‐ (IBAction)crashButtonTapped:(id)sender {
    @[][1];
}

@end

Crie e execute o app no Xcode com o depurador do Xcode desconectado.

O depurador do Xcode impede que relatórios de erros sejam enviados para o Crashlytics. Conclua as etapas a seguir para desconectar seu dispositivo de teste ou simulador do depurador do Xcode antes de forçar uma falha.
1. Clique em Build and then run the current scheme para criar seu app em um dispositivo de teste ou simulador.
2. Aguarde até que o app esteja em execução e clique em Stop running the scheme or action para fechar a instância inicial do app. Ela inclui o depurador que interfere no Crashlytics.
Force a falha de teste para enviar o primeiro relatório de erros do app:
1. Abra o app na tela inicial do dispositivo de teste ou do simulador.
2. No app, pressione o botão "Testar falha" que você adicionou usando o código acima.
3. Depois que o app falhar, execute-o novamente no Xcode para que ele possa enviar o relatório de falhas ao Firebase.
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

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.