Falhas no App Center (React Native)

As falhas do App Center gerarão automaticamente um log de falhas sempre que o aplicativo falhar. O log é gravado pela primeira vez no armazenamento do dispositivo e, quando o usuário inicia o aplicativo novamente, o relatório de falha será enviado para o App Center. A coleta de falhas funciona para aplicativos beta e ao vivo, ou seja, aqueles enviados para o Google Play. Os logs de falha contêm informações valiosas para ajudar a corrigir a falha.

Siga a seção Introdução se você ainda não configurou o SDK em seu aplicativo.

Onde quer que você esteja usando o App Center Crashes, adicione a seguinte importação no início do arquivo.

// Import App Center Crashes at the top of the file.
import Crashes from 'appcenter-crashes';

Gerar uma falha de teste

O App Center Crashes fornece uma API para simular um crash de teste, facilitando o teste do SDK. Essa API só pode ser usada em aplicativos de teste/beta e não fará nada em aplicativos de produção.

Crashes.generateTestCrash();

Também é fácil gerar uma falha do JavaScript. Adicione a linha a seguir ao código, que gera um erro JavaScript e causa uma falha.

throw new Error('This is a test javascript crash!');

Obter mais informações sobre uma falha anterior

O App Center Crashes tem duas APIs que fornecem mais informações caso o aplicativo tenha falhado.

O aplicativo recebeu um aviso de memória baixa na sessão anterior?

A qualquer momento após iniciar o SDK, você pode verificar se o aplicativo recebeu um aviso de memória na sessão anterior:

const hadLowMemoryWarning = await Crashes.hasReceivedMemoryWarningInLastSession();

O aplicativo falhou na sessão anterior?

A qualquer momento após iniciar o SDK, você pode verificar se o aplicativo falhou na inicialização anterior:

const didCrash = await Crashes.hasCrashedInLastSession();

Isso é útil caso você deseje ajustar o comportamento ou a interface do usuário do seu aplicativo depois que ocorreu uma falha. Alguns desenvolvedores optam por mostrar uma interface do usuário adicional para pedir desculpas aos usuários ou querem encontrar um meio de entrar em contato depois que ocorre uma falha.

Detalhes sobre a última falha

Se o aplicativo falhou anteriormente, você pode obter detalhes sobre a última falha.

const crashReport = await Crashes.lastSessionCrashReport();

Personalize o uso do recurso de falhas do App Center

O App Center Crashes fornece retornos de chamada para os desenvolvedores executarem ações adicionais antes de enviar e ao enviar relatórios de falhas para o App Center.

Falha no processamento no JavaScript

Para que seus Crash.setListener métodos funcionem conforme o esperado, você precisa verificar se o aplicativo está configurado corretamente.

1. Abra o arquivo do ios/YourAppName/AppDelegate.m projeto e verifique se você tem [AppCenterReactNativeCrashes register]; em vez de [AppCenterReactNativeCrashes registerWithAutomaticProcessing];.
2. Abra o android/app/src/main/res/values/strings.xml do projeto e verifique se appCenterCrashes_whenToSendCrashes esteja configurado para ASK_JAVASCRIPT.

Todos os diferentes retornos de chamada do ouvinte de eventos são discutidos um a um neste documento, mas você precisa definir um ouvinte de eventos que defina todos os retornos de chamada ao mesmo tempo.

A falha deve ser processada?

Implemente este callback se você quiser decidir se uma falha específica precisa ser processada ou não. Por exemplo, pode haver uma falha no nível do sistema que você deseja ignorar e que não deseja enviar para o App Center.

Crashes.setListener({

    shouldProcess: function (report) {
        return true; // return true if the crash report should be processed, otherwise false.
    },

    // Other callbacks must also be defined at the same time if used.
    // Default values are used if a method with return parameter isn't defined.
});

Solicitar o consentimento do usuário para enviar um log de falhas

Se a privacidade do usuário for importante para você, você deverá obter a confirmação do usuário antes de enviar um relatório de falha para o App Center. O SDK expõe um retorno de chamada que indica ao App Center Crashes para aguardar a confirmação do usuário antes de enviar quaisquer relatórios de falhas.

Se você optar por fazer isso, será responsável por obter a confirmação do usuário, por exemplo, por meio de um prompt de diálogo com uma das seguintes opções: Sempre Enviar, Enviar e Não enviar. Com base na entrada, você indicará ao App Center Crashes o que fazer, e a falha será tratada adequadamente.

O seguinte callback mostra como instruir o SDK a aguardar a confirmação do usuário antes de enviar crashes.

Crashes.setListener({

    shouldAwaitUserConfirmation: function (report) {

        // Build your own UI to ask for user consent here. SDK doesn't provide one by default.

        // Return true if you built a UI for user consent and are waiting for user input on that custom UI, otherwise false.
        return true;
    },

    // Other callbacks must also be defined at the same time if used.
    // Default values are used if a method with return parameter isn't defined.
});

Se você retornar true, seu aplicativo deverá obter (usando seu próprio código) a permissão do usuário e atualizar o SDK com o resultado usando a seguinte API:

import Crashes, { UserConfirmation } from 'appcenter-crashes';

// Depending on the user's choice, call Crashes.notifyUserConfirmation() with the right value.
Crashes.notifyUserConfirmation(UserConfirmation.DONT_SEND);
Crashes.notifyUserConfirmation(UserConfirmation.SEND);
Crashes.notifyUserConfirmation(UserConfirmation.ALWAYS_SEND);

Obter informações sobre o status de envio de um relatório de erro

Às vezes, você deseja saber o status da falha do aplicativo. Um caso de uso comum é que talvez você queira mostrar a interface do usuário que informa aos usuários que seu aplicativo está enviando um relatório de falha ou, caso seu aplicativo esteja falhando rapidamente após a inicialização, você deseja ajustar o comportamento do aplicativo para garantir que os logs de falha possam ser enviados. O App Center Crashes tem três diferentes retornos de chamada que você pode usar em seu aplicativo para receber notificações sobre os eventos ocorridos.

Para fazer isso, defina um ouvinte de eventos em seu código, conforme mostrado no exemplo a seguir:

Crashes.setListener({
    onBeforeSending: function (report) {
        // called after Crashes.process and before sending the crash.
    },
    onSendingSucceeded: function (report) {
        // called when crash report sent successfully.
    },
    onSendingFailed: function (report) {
        // called when crash report couldn't be sent.
    }

    // Other callbacks must also be defined at the same time if used.
    // Default values are used if a method with return parameter isn't defined.
});

Todos os retornos de chamada são opcionais. Você não precisa fornecer todos os 3 métodos no objeto do ouvinte de eventos, por exemplo, você só pode implementar onBeforeSending.

O recebimento onSendingFailed significa que ocorreu um erro não recuperável, como um código 4xx . Por exemplo, 401 significa que está appSecret errado.

Esse retorno de chamada não será ativado se for um problema de rede. Nesse caso, o SDK continua tentando novamente (e também pausa novas tentativas enquanto a conexão de rede está inativa). Caso tenhamos problemas de rede ou uma interrupção no ponto de extremidade e você reinicie o aplicativo, onBeforeSending será disparado novamente após a reinicialização do processo.

Adicionar anexos a um relatório de falha

Você pode adicionar anexos binários e de texto a um relatório de falha. O SDK enviará essas informações junto com a falha, para que você possa vê-las no portal do App Center. O callback a seguir é invocado imediatamente antes de enviar a falha armazenada de lançamentos anteriores do aplicativo. Ele não será invocado quando o acidente acontecer. Verifique se o arquivo de anexo não está nomeado minidump.dmp , pois esse nome está reservado para arquivos de minidump. Aqui está um exemplo de como anexar texto e uma imagem a um crash:

import Crashes, { ErrorAttachmentLog } from 'appcenter-crashes';

Crashes.setListener({
    getErrorAttachments(report) {
        const textAttachment = ErrorAttachmentLog.attachmentWithText('Hello text attachment!', 'hello.txt');
        const binaryAttachment = ErrorAttachmentLog.attachmentWithBinary(`${imageAsBase64string}`, 'logo.png', 'image/png');
        return [textAttachment, binaryAttachment];
    }

    // Other callbacks must also be defined at the same time if used.
    // Default values are used if a method with return parameter isn't defined.
});

O fileName parâmetro é opcional (pode ser null) e é usado apenas no portal do App Center. A partir de uma ocorrência de falha específica no portal, você pode ver anexos e baixá-los. Se você especificou um nome de arquivo, esse será o nome do arquivo a ser baixado, caso contrário, o nome do arquivo será gerado para você.

Para configurar o getErrorAttachments retorno de chamada para funcionar com funções assíncronas/await do ES2017, retorne uma Promessa atendida. O exemplo a seguir anexa um texto e uma imagem a um crash de forma assíncrona:

import Crashes, { ErrorAttachmentLog } from 'appcenter-crashes';

Crashes.setListener({
    getErrorAttachments(report) {
        return (async () => {
            const textContent = await readTextFileAsync(); // use your async function to read text file
            const binaryContent = await readBinaryFileAsync(); // use your async function to read binary file
            const textAttachment = ErrorAttachmentLog.attachmentWithText(textContent, 'hello.txt');
            const binaryAttachment = ErrorAttachmentLog.attachmentWithBinary(binaryContent, 'logo.png', 'image/png');
            return [textAttachment, binaryAttachment];
        })();
    }

    // Other callbacks must also be defined at the same time if used.
    // Default values are used if a method with return parameter isn't defined.
});

Erros tratados

O App Center também permite que você rastreie erros usando exceções manipuladas por meio do trackError método. Opcionalmente, um aplicativo pode anexar propriedades ou/e anexos a um relatório de erros manipulado para fornecer mais contexto.

try {
    // Throw error.
} catch (error) {

    // Prepare properties.
    const properties = { 'Category' : 'Music', 'Wifi' : 'On' };

    // Prepare attachments.
    const textAttachment = ErrorAttachmentLog.attachmentWithText('Hello text attachment!', 'hello.txt');
    const attachments = [textAttachment];

    // Create an exception model from error.
    const exceptionModel1 = ExceptionModel.createFromError(error);

    // ..or generate with your own error data.
    const exceptionModel2 = ExceptionModel.createFromTypeAndMessage("type", "message", "stacktrace");

    // Track error with custom data.
    Crashes.trackError(exceptionModel1, properties, attachments);
    Crashes.trackError(exceptionModel1, properties, nil);
    Crashes.trackError(exceptionModel2, nil, attachments);
    Crashes.trackError(exceptionModel2, nil, nil);
}

Breakpad

O App Center dá suporte a falhas do Breakpad do NDK do Android em um aplicativo React Native.

Siga as etapas normais de instalação acima e, em sua MainActivity.java substituição OnCreate , adicione a configuração de minidump e chame seu código nativo que configura a configuração do Breakpad.

Exemplo:

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    Crashes.getMinidumpDirectory().thenAccept(new AppCenterConsumer<String>() {
      @Override
      public void accept(String path) {
        // Path is null when Crashes is disabled.
        if (path != null) {
          // links to NDK
          setupBreakpadListener(path);
        }
      }
    });
  }

Habilitar ou desabilitar falhas do App Center no tempo de execução

Você pode habilitar e desabilitar o Crashes no App Center durante o tempo de execução. Se você desabilitá-lo, o SDK não fará nenhum relatório de falha para o aplicativo.

await Crashes.setEnabled(false);

Para habilitar o App Center Crashes novamente, use a mesma API, mas passe true como um parâmetro.

await Crashes.setEnabled(true);

O estado é mantido no armazenamento do dispositivo entre as inicializações do aplicativo.

Verificar se o recurso de 'Crashes' do App Center está habilitado

Você também pode verificar se o recurso App Center Crashes está habilitado ou não:

const enabled = await Crashes.isEnabled();