Awarie usługi App Center (React Native)

Awarie usługi App Center automatycznie generują dziennik awarii za każdym razem, gdy aplikacja ulegnie awarii. Dziennik jest najpierw zapisywany w magazynie urządzenia, a gdy użytkownik ponownie uruchomi aplikację, raport o awarii zostanie wysłany do Centrum aplikacji. Zbieranie awarii działa zarówno w przypadku aplikacji beta, jak i działających publicznie, czyli przesłanych do Google Play. Dzienniki awarii zawierają cenne informacje ułatwiające naprawienie awarii.

Postępuj zgodnie z sekcją Wprowadzenie , jeśli zestaw SDK nie został jeszcze skonfigurowany w aplikacji.

Wszędzie tam, gdzie używasz usługi App Center Crashes, dodaj następujący import na początku pliku.

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

Generowanie awarii testowej

App Center Crashes zapewnia interfejs API do generowania testowej awarii w celu łatwego testowania SDK. Ten interfejs API może być używany tylko w aplikacjach testowych/beta i nie będzie wykonywać żadnych czynności w aplikacjach produkcyjnych.

Crashes.generateTestCrash();

Można również łatwo wygenerować awarię języka JavaScript. Dodaj następujący wiersz do kodu, który zgłasza błąd języka JavaScript i powoduje awarię.

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

Uzyskaj więcej informacji o poprzedniej awarii

Usługa App Center Crash ma dwa interfejsy API, które zapewniają więcej informacji na wypadek awarii aplikacji.

Czy aplikacja otrzymała ostrzeżenie o niskiej ilości pamięci w poprzedniej sesji?

W dowolnym momencie po uruchomieniu zestawu SDK możesz sprawdzić, czy aplikacja otrzymała ostrzeżenie o pamięci w poprzedniej sesji:

const hadLowMemoryWarning = await Crashes.hasReceivedMemoryWarningInLastSession();

Czy aplikacja uległa awarii w poprzedniej sesji?

W dowolnym momencie po uruchomieniu zestawu SDK możesz sprawdzić, czy aplikacja uległa awarii w poprzednim uruchomieniu:

const didCrash = await Crashes.hasCrashedInLastSession();

Jest to przydatne w przypadku, gdy chcesz dostosować zachowanie lub interfejs użytkownika aplikacji po wystąpieniu awarii. Niektórzy deweloperzy zdecydowali się pokazać dodatkowy interfejs użytkownika, aby przeprosić swoich użytkowników lub chcieć skontaktować się po wystąpieniu awarii.

Szczegóły dotyczące ostatniej awarii

Jeśli aplikacja uległa awarii wcześniej, możesz uzyskać szczegółowe informacje o ostatniej awarii.

const crashReport = await Crashes.lastSessionCrashReport();

Dostosowywanie użytkowania funkcji App Center Crashes

Usługa App Center Crash udostępnia wywołania zwrotne dla deweloperów do wykonywania dodatkowych akcji przed i podczas wysyłania dzienników awarii do Centrum aplikacji.

Przetwarzanie błędów w JavaScript

Aby metody Crash.setListener działały zgodnie z oczekiwaniami, należy sprawdzić, czy aplikacja została prawidłowo skonfigurowana.

1. Otwórz plik projektu ios/YourAppName/AppDelegate.m i sprawdź, czy masz [AppCenterReactNativeCrashes register]; zamiast [AppCenterReactNativeCrashes registerWithAutomaticProcessing];.
2. Otwórz plik projektu android/app/src/main/res/values/strings.xml i sprawdź, czy appCenterCrashes_whenToSendCrashes jest ustawione na ASK_JAVASCRIPT.

Wszystkie różne wywołania zwrotne odbiornika zdarzeń są omawiane jeden po jednym w tym dokumencie, ale należy ustawić jeden odbiornik zdarzeń, który definiuje wszystkie wywołania zwrotne jednocześnie.

Czy awaria powinna zostać przetworzona?

Zaimplementuj to wywołanie zwrotne, jeśli chcesz zdecydować, czy należy przetworzyć konkretną awarię, czy nie. Na przykład może wystąpić awaria na poziomie systemu, którą chcesz zignorować i że nie chcesz wysyłać do Centrum aplikacji.

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.
});

Poproś użytkownika o zgodę na wysłanie dziennika awarii

Jeśli prywatność użytkownika jest dla Ciebie ważna, przed wysłaniem raportu o awarii do Centrum aplikacji należy uzyskać potwierdzenie użytkownika. SDK udostępnia wywołanie zwrotne, które informuje funkcję App Center Crashes o konieczności oczekiwania na potwierdzenie użytkownika przed wysłaniem raportów o awariach.

Jeśli zdecydujesz się to zrobić, odpowiadasz za uzyskanie potwierdzenia użytkownika, np. za pośrednictwem okna dialogowego z jedną z następujących opcji: Zawsze wysyłaj, Wysyłaj i Nie wysyłaj. Na podstawie danych wejściowych poinstruujesz App Center Crashes, co należy zrobić, a awaria zostanie odpowiednio obsłużona.

Poniższe wywołanie zwrotne pokazuje, jak poinformować pakiet SDK o oczekiwaniu na potwierdzenie użytkownika przed wysłaniem raportów o błędach:

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.
});

Jeśli zwrócisz true, aplikacja musi uzyskać (przy użyciu własnego kodu) uprawnienie użytkownika i zaktualizować zestaw SDK z wynikiem, korzystając z następującego interfejsu 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);

Uzyskaj informacje o stanie wysyłki dziennika awarii

Czasami chcesz poznać stan awarii aplikacji. Typowy przypadek użycia polega na tym, że możesz pokazać interfejs użytkownika, który informuje użytkowników, że aplikacja przesyła raport o awarii lub w przypadku, gdy aplikacja ulega awarii szybko po uruchomieniu, chcesz dostosować zachowanie aplikacji, aby upewnić się, że dzienniki awarii można przesłać. Usługa App Center Crash ma trzy różne wywołania zwrotne, których można użyć w aplikacji, aby otrzymywać powiadomienia o tym, co się dzieje.

W tym celu zdefiniuj odbiornik zdarzeń w kodzie, jak pokazano w poniższym przykładzie:

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.
});

Wszystkie wywołania zwrotne są opcjonalne. Nie musisz udostępniać wszystkich 3 metod w obiekcie odbiornika zdarzeń, na przykład można zaimplementować tylko onBeforeSending.

Odbieranie onSendingFailed oznacza, że wystąpił błąd niemożliwy do odzyskania, taki jak kod 4xx . Na przykład 401 oznacza, że appSecret jest nieprawidłowy.

Ten callback nie zostanie wywołany, jeśli jest to problem z siecią. W takim przypadku zestaw SDK ponawia próbę (a także wstrzymuje ponawianie próby, gdy połączenie sieciowe nie działa). W przypadku problemów z siecią lub przestoju na końcowym punkcie i ponownego uruchomienia aplikacji, onBeforeSending zostanie uruchomiony ponownie po restarcie procesu.

Dodawanie załączników do raportu o awarii

Do raportu o awarii można dodawać załączniki binarne i tekstowe. Zestaw SDK wyśle je wraz z awarią, aby można było je zobaczyć w portalu usługi App Center. Następujące wywołanie zwrotne jest wywoływane bezpośrednio przed wysłaniem przechowywanej awarii z poprzednich uruchomień aplikacji. Nie będzie wywoływana, gdy wystąpi awaria. Upewnij się, że plik załącznika nie ma nazwy minidump.dmp , ponieważ ta nazwa jest zarezerwowana dla plików minidump. Oto przykład dołączania tekstu i obrazu do awarii:

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.
});

Parametr fileName jest opcjonalny (może być null) i jest używany tylko w portalu Centrum aplikacji. Na podstawie konkretnego zdarzenia awarii w portalu można wyświetlać i pobierać załączniki. Jeśli określono nazwę pliku, będzie to nazwa pliku do pobrania, w przeciwnym razie nazwa pliku zostanie wygenerowana.

Aby skonfigurować getErrorAttachments wywołanie zwrotne do pracy z funkcjami async/await ES2017, zamiast tego zwróć spełnioną obietnicę. Poniższy przykład dołącza tekst i obraz do awarii w sposób asynchroniczny:

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.
});

Zarządzane błędy

Usługa App Center umożliwia również monitorowanie błędów przy użyciu obsługiwanych wyjątków metodą trackError. Aplikacja może opcjonalnie dołączyć właściwości lub/i załączniki do obsługiwanego raportu o błędach w celu zapewnienia dalszego kontekstu.

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);
}

Mechanizm raportowania awarii

App Center obsługuje awarie Breakpad z Android NDK w aplikacjach React Native.

Postępuj zgodnie z powyższymi normalnymi krokami konfiguracji, a następnie w swoim MainActivity.java zastąpieniu dodaj konfigurację minidump i wywołaj metodę do kodu natywnego, który konfiguruje Twoją konfigurację programu Breakpad.

Przykład:

  @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);
        }
      }
    });
  }

Włączanie lub wyłączanie funkcji raportowania awarii w App Center w czasie wykonywania

Możesz włączyć i wyłączyć funkcję zarządzania awariami w usłudze App Center w czasie wykonywania. Jeśli go wyłączysz, zestaw SDK nie będzie wykonywać żadnych raportów dotyczących awarii dla aplikacji.

await Crashes.setEnabled(false);

Aby ponownie włączyć funkcję Crashes w usłudze App Center, użyj tego samego interfejsu API, ale przekaż true jako parametr.

await Crashes.setEnabled(true);

Stan jest utrwalany w magazynie urządzenia w ramach uruchamiania aplikacji.

Sprawdź, czy raportowanie awarii w App Center jest włączone

Możesz również sprawdzić, czy usługa App Center Ulega awarii jest włączona, czy nie:

const enabled = await Crashes.isEnabled();