App Center Abstürze (iOS)

App Center Abstürze generiert bei jedem Absturz Ihrer App automatisch ein Absturzprotokoll. Das Protokoll wird zuerst in den Speicher des Geräts geschrieben, und wenn der Benutzer die App erneut startet, wird der Absturzbericht an App Center. Das Sammeln von Abstürzen funktioniert sowohl für Beta- als auch für Live-Apps, d. h. für Apps, die an die App Store. Absturzprotokolle enthalten wertvolle Informationen, mit deren Hilfe Sie den Absturz beheben können.

Befolgen Sie Erste Schritte Abschnitt , wenn Sie das SDK noch nicht in Ihrer Anwendung eingerichtet haben.

Außerdem ist für Absturzprotokolle unter iOS eine symbolische Verknüpfung erforderlich. Informationen zum Bereitstellen von Symbolen für Ihre App finden Sie in der App Center Diagnostics-Dokumentation.

Hinweis

Das SDK gibt kein Absturzprotokoll weiter, wenn Sie an den Debugger angefügt sind. Stellen Sie sicher, dass der Debugger nicht angefügt ist, wenn Sie die App abstürzen.

Hinweis

Stellen Sie sicher, dass Bitcode deaktiviert ist, um ordnungsgemäß symbolische Stapelüberwachungen zu erhalten. Weitere Informationen zu Bitcode finden Sie in App Center iOS Symbolication -Dokumentation.

Hinweis

In der 4.0.0 Version von App Center Breaking Changes eingeführt. Führen Sie den Abschnitt Migrieren App Center SDK 4.0.0 und höher aus, um App Center früheren Versionen zu migrieren.

Absturzberichterstellung in Erweiterungen

App Center unterstützt die Absturzberichterstellung in iOS-Erweiterungen. Die Verwendung ist die gleiche wie in der Containeranwendung.

Generieren eines Testabsturzes

App Center Crashes bietet Ihnen eine API zum Generieren eines Testabsturzes für einfache Tests des SDK. Diese API kann nur in Test-/Beta-Apps verwendet werden und kann in Produktions-Apps nicht verwendet werden.

[MSACCrashes generateTestCrash];
Crashes.generateTestCrash()

Weitere Informationen zu einem früheren Absturz

App Center Crashes verfügt über zwei APIs, die Ihnen weitere Informationen für den Fall geben, dass Ihre App abgestürzt ist.

Hat die App in der vorherigen Sitzung eine Warnung zu wenig Arbeitsspeicher erhalten?

Nach dem Starten des SDK können Sie jederzeit überprüfen, ob die App in der vorherigen Sitzung eine Arbeitsspeicherwarnung erhalten hat:

[MSACCrashes hasReceivedMemoryWarningInLastSession];
Crashes.hasReceivedMemoryWarningInLastSession

Hinweis

Diese Methode darf nur verwendet werden, nachdem Crashes gestartet wurde. Sie wird immer NO oder vor dem Start false zurückgegeben.

Hinweis

In einigen Fällen kann ein Gerät mit wenig Arbeitsspeicher keine Ereignisse senden.

Ist die App in der vorherigen Sitzung abgestürzt?

Nach dem Starten des SDK können Sie jederzeit überprüfen, ob die App beim vorherigen Start abgestürzt ist:

[MSACCrashes hasCrashedInLastSession];
Crashes.hasCrashedInLastSession

Dies ist hilfreich, wenn Sie das Verhalten oder die Benutzeroberfläche Ihrer App nach einem Absturz anpassen möchten.

Hinweis

Diese Methode darf nur verwendet werden, nachdem MSACCrashes gestartet wurde. Sie wird immer NO oder vor dem Start false zurückgegeben.

Details zum letzten Absturz

Wenn Ihre App zuvor abgestürzt ist, können Sie Details zum letzten Absturz abrufen.

MSACErrorReport *crashReport = [MSACCrashes lastSessionCrashReport];
var crashReport = Crashes.lastSessionCrashReport

Hinweis

Diese Methode darf nur verwendet werden, nachdem Crashes gestartet wurde. Sie wird immer nil vor dem Start zurückgegeben.

Es gibt zahlreiche Anwendungsfälle für diese API. Am häufigsten wird diese API aufgerufen und ihr benutzerdefiniertes CrashesDelegateimplementiert.

Anpassen der Nutzung von App Center Abstürzen

App Center Crashes (Abstürze) bietet Entwicklern Rückrufe zum Ausführen zusätzlicher Aktionen vor und beim Senden von Absturzprotokollen an App Center.

Um Ihr benutzerdefiniertes Verhalten hinzuzufügen, müssen Sie CrashesDelegate -protocol übernehmen. Alle seine Methoden sind optional.

Registrieren als Delegat

[MSACCrashes setDelegate:self];
Crashes.delegate = self

Hinweis

Sie müssen den Delegaten festlegen, bevor Sie aufrufen, da App Center die Verarbeitung unmittelbar AppCenter.start nach dem Start abstürzt.

Sollte der Absturz verarbeitet werden?

Implementieren Sie die -methode in der Klasse, die das -Protocol übernimmt, wenn Sie entscheiden möchten, ob ein bestimmter Absturz crashes:shouldProcessErrorReport: verarbeitet werden muss oder CrashesDelegate nicht. Beispielsweise kann es zu einem Absturz auf Systemebene geben, den Sie ignorieren möchten und den Sie nicht an die App Center.

- (BOOL)crashes:(MSACCrashes *)crashes shouldProcessErrorReport:(MSACErrorReport *)errorReport {
  return YES; // return YES if the crash report should be processed, otherwise NO.
}
func crashes(_ crashes: Crashes, shouldProcess errorReport: ErrorReport) -> Bool {
  return true; // return true if the crash report should be processed, otherwise false.
}

Wenn Datenschutz für Sie wichtig ist, sollten Sie eine Benutzerbestätigung erhalten, bevor Sie einen Absturzbericht an App Center senden. Das SDK macht einen Rückruf verfügbar, der App Center Abstürze angibt, auf die Benutzerbestätigung zu warten, bevor Absturzberichte gesendet werden.

Wenn Sie dies ausgewählt haben, sind Sie dafür verantwortlich, die Bestätigung des Benutzers zu erhalten, z. B. über eine Dialogeingabeaufforderung mit einer der folgenden Optionen: Immer senden, senden und nicht senden. Basierend auf der Eingabe teilen Sie App Center ab, was zu tun ist, und der Absturz wird dann entsprechend behandelt.

Hinweis

Das SDK zeigt dafür kein Dialogfeld an. Die App muss eine eigene Benutzeroberfläche bereitstellen, um die Zustimmung des Benutzers einzuholen.

Hinweis

Die App sollte nicht notifyWithUserConfirmation explizit aufrufen, wenn sie kein Benutzerbestätigungsdialogfeld implementiert. Das Crashes-Modul verarbeitet implizit das Senden von Protokollen für Sie.

Die folgende Methode zeigt, wie Sie einen Benutzerbestätigungshandler einrichten:

[MSACCrashes setUserConfirmationHandler:(^(NSArray<MSACErrorReport *> *errorReports) {

  // Your code to present your UI to the user, e.g. an UIAlertController.
  UIAlertController *alertController = [UIAlertController
      alertControllerWithTitle:@"Sorry about that!"
                      message:@"Do you want to send an anonymous crash report so we can fix the issue?"
                preferredStyle:UIAlertControllerStyleAlert];

  [alertController
      addAction:[UIAlertAction actionWithTitle:@"Don't send"
                                        style:UIAlertActionStyleCancel
                                      handler:^(UIAlertAction *action) {
                                        [MSACCrashes notifyWithUserConfirmation:MSACUserConfirmationDontSend];
                                      }]];

  [alertController
      addAction:[UIAlertAction actionWithTitle:@"Send"
                                        style:UIAlertActionStyleDefault
                                      handler:^(UIAlertAction *action) {
                                        [MSACCrashes notifyWithUserConfirmation:MSACUserConfirmationSend];
                                      }]];

  [alertController
      addAction:[UIAlertAction actionWithTitle:@"Always send"
                                        style:UIAlertActionStyleDefault
                                      handler:^(UIAlertAction *action) {
                                        [MSACCrashes notifyWithUserConfirmation:MSACUserConfirmationAlways];
                                      }]];
  // Show the alert controller.
  [self.window.rootViewController presentViewController:alertController animated:YES completion:nil];
  return YES; // Return YES if the SDK should await user confirmation, otherwise NO.
})];
Crashes.setUserConfirmationHandler({ (errorReports: [ErrorReport]) in

  // Your code to present your UI to the user, e.g. an UIAlertController.
  let alertController = UIAlertController(title: "Sorry about that!",
                                          message: "Do you want to send an anonymous crash report so we can fix the issue?",
                                          preferredStyle:.alert)

  alertController.addAction(UIAlertAction(title: "Don't send", style: .cancel) {_ in
    Crashes.notify(with: .dontSend)
  })

  alertController.addAction(UIAlertAction(title: "Send", style: .default) {_ in
    Crashes.notify(with: .send)
  })

  alertController.addAction(UIAlertAction(title: "Always send", style: .default) {_ in
    Crashes.notify(with: .always)
  })

  // Show the alert controller.
  self.window?.rootViewController?.present(alertController, animated: true)
  return true // Return true if the SDK should await user confirmation, otherwise return false.
})

Falls Sie YES / true im obigen Handlerblock zurückkehren, sollte Ihre App die Benutzerberechtigung erhalten und das SDK mithilfe der folgenden API mit dem Ergebnis informieren. Wenn Sie hierfür wie im obigen Beispiel eine Warnung verwenden, würden Sie sie aus Ihrer Implementierung des alertView:clickedButtonAtIndex: -Rückrufs aufrufen.

// Depending on the users's choice, call notifyWithUserConfirmation: with the right value.
[MSACCrashes notifyWithUserConfirmation:MSACUserConfirmationDontSend];
[MSACCrashes notifyWithUserConfirmation:MSACUserConfirmationSend];
[MSACCrashes notifyWithUserConfirmation:MSACUserConfirmationAlways];
// Depending on the user's choice, call notify(with:) with the right value.
Crashes.notify(with: .dontSend)
Crashes.notify(with: .send)
Crashes.notify(with: .always)

Abrufen von Informationen zum Sendestatus für ein Absturzprotokoll

Manchmal möchten Sie den Status des App-Absturzes kennen. Ein häufiger Anwendungsfall ist, dass Sie möglicherweise eine Benutzeroberfläche anzeigen möchten, die die Benutzer darüber informiert, dass Ihre App einen Absturzbericht übermittelt. Falls Ihre App nach dem Start schnell abstürzt, möchten Sie das Verhalten der App anpassen, um sicherzustellen, dass die Absturzprotokolle übermittelt werden können. Das CrashesDelegate -Protokoll definiert drei verschiedene Rückrufe, die Sie in Ihrer App verwenden können, um benachrichtigt zu werden, was passiert:

Der folgende Rückruf wird aufgerufen, bevor das SDK ein Absturzprotokoll sendet.

- (void)crashes:(MSACCrashes *)crashes willSendErrorReport:(MSACErrorReport *)errorReport {
  // Your code, e.g. to present a custom UI.
}
func crashes(_ crashes: Crashes, willSend errorReport: ErrorReport) {
  // Your code, e.g. to present a custom UI.
}

Falls netzwerkprobleme oder ein Ausfall auf dem Endpunkt auftreten und Sie die App neu starten, wird nach dem Neustart des willSendErrorReport Prozesses erneut ausgelöst.

Der folgende Rückruf wird aufgerufen, nachdem das SDK erfolgreich ein Absturzprotokoll gesendet hat.

- (void)crashes:(MSACCrashes *)crashes didSucceedSendingErrorReport:(MSACErrorReport *)errorReport {
  // Your code, e.g. to hide the custom UI.
}
func crashes(_ crashes: Crashes, didSucceedSending errorReport: ErrorReport) {
  // Your code goes here.
}

Der folgende Rückruf wird aufgerufen, wenn das SDK kein Absturzprotokoll senden konnte.

- (void)crashes:(MSACCrashes *)crashes didFailSendingErrorReport:(MSACErrorReport *)errorReport withError:(NSError *)error {
  // Your code goes here.
}
func crashes(_ crashes: Crashes, didFailSending errorReport: ErrorReport, withError error: Error) {
  // Your code goes here.
}

Empfangen didFailSendingErrorReport bedeutet, dass ein nicht wiederherstellbarer Fehler aufgetreten ist, z. B. ein 4xx-Code. 401 bedeutet beispielsweise, dass appSecret falsch ist.

Dieser Rückruf wird nicht ausgelöst, wenn es sich um ein Netzwerkproblem handelt. In diesem Fall führt das SDK die Wiederholungen durch (und hält auch Wiederholungen an, während die Netzwerkverbindung unterbrochen wird).

Hinzufügen von Anlagen zu einem Absturzbericht

Sie können einem Absturzbericht Binär- und Textanlagen hinzufügen. Das SDK sendet sie zusammen mit dem Absturz, damit Sie sie im App Center-Portal sehen können. Der folgende Rückruf wird direkt vor dem Senden des gespeicherten Absturzes von früheren Anwendungsstarts aufgerufen. Sie wird nicht aufgerufen, wenn der Absturz auftritt. Hier sehen Sie ein Beispiel für das Anfügen von Text und eines Bilds an einen Absturz:

- (NSArray<MSACErrorAttachmentLog *> *)attachmentsWithCrashes:(MSACCrashes *)crashes
                                             forErrorReport:(MSACErrorReport *)errorReport {
  MSACErrorAttachmentLog *attachment1 = [MSACErrorAttachmentLog attachmentWithText:@"Hello world!" filename:@"hello.txt"];
  MSACErrorAttachmentLog *attachment2 = [MSACErrorAttachmentLog attachmentWithBinary:[@"Fake image" dataUsingEncoding:NSUTF8StringEncoding] filename:@"fake_image.jpeg" contentType:@"image/jpeg"];
  return @[ attachment1, attachment2 ];
}
func attachments(with crashes: Crashes, for errorReport: ErrorReport) -> [ErrorAttachmentLog]? {
  let attachment1 = ErrorAttachmentLog.attachment(withText: "Hello world!", filename: "hello.txt")
  let attachment2 = ErrorAttachmentLog.attachment(withBinary: "Fake image".data(using: String.Encoding.utf8), filename: nil, contentType: "image/jpeg")
  return [attachment1!, attachment2!]
}

Hinweis

Das Größenlimit beträgt derzeit 7 MB. Der Versuch, eine größere Anlage zu senden, löst einen Fehler aus.

Aktivieren oder Deaktivieren App Center Abstürze zur Laufzeit

Sie können App Center Abstürze zur Laufzeit aktivieren und deaktivieren. Wenn Sie es deaktivieren, erstellt das SDK keine Absturzberichte für die App.

[MSACCrashes setEnabled:NO];
Crashes.enabled = false

Verwenden Sie zum erneuten Aktivieren App Center Abstürze die gleiche API, übergeben Sie jedoch YES / true als Parameter.

[MSACCrashes setEnabled:YES];
Crashes.enabled = true

Der Zustand wird über Anwendungsstarts hinweg im Speicher des Geräts beibehalten.

Hinweis

Diese Methode darf nur verwendet werden, nachdem Crashes gestartet wurde.

Überprüfen Sie, ob App Center Abstürze aktiviert ist.

Sie können auch überprüfen, ob App Center Abstürze aktiviert ist oder nicht:

BOOL enabled = [MSACCrashes isEnabled];
var enabled = Crashes.enabled

Hinweis

Diese Methode darf nur verwendet werden, nachdem Crashes gestartet wurde. Sie wird immer false vor dem Start zurückgegeben.

Deaktivieren der Ausnahmebehandlung für Mach

Standardmäßig verwendet App Center Crashes den Ausnahmehandler Von Mach, um schwerwiegende Signale, z. B. Stapelüberläufe, über einen Mach-Ausnahmeserver abzufangen.

Die disableMachExceptionHandler -Methode bietet eine Option zum Deaktivieren des Abfangens schwerwiegender Signale über einen Mach-Ausnahmeserver. Wenn Sie den Ausnahmehandler "Mach" deaktivieren möchten, sollten Sie diese Methode aufrufen, BEVOR Sie das SDK starten. Ihr typischer Setupcode würde wie folgt aussehen:

[MSACCrashes disableMachExceptionHandler];
[MSACAppCenter start:@"{Your App Secret}" withServices:@[[MSACAnalytics class], [MSACCrashes class]]];
Crashes.disableMachExceptionHandler()
AppCenter.start(withAppSecret: "{Your App Secret}", services: [Analytics.self, Crashes.self])