Chybové ukončení App Center (iOS)
Důležité
31. března 2025 je naplánované vyřazení z provozu. I když můžete dál používat Visual Studio App Center, dokud ho úplně vyřadíte, existuje několik doporučených alternativ, na které můžete zvážit migraci.
Přečtěte si další informace o časových osách a alternativách podpory.
Chybové ukončení App Center automaticky vygeneruje protokol chybových ukončení pokaždé, když dojde k chybovému ukončení aplikace. Protokol se nejprve zapíše do úložiště zařízení a když uživatel aplikaci znovu spustí, odešle se do App Center zpráva o chybovém ukončení. Shromažďování chyb funguje pro beta i živé aplikace, tj. ty, které byly odeslány do App Store. Protokoly chyb obsahují cenné informace, které vám pomůžou chybu opravit.
Pokud jste v aplikaci ještě nenastavili sadu SDK, postupujte podle části Začínáme.
Protokoly chyb v iOSu také vyžadují symboliku. Přečtěte si dokumentaci k diagnostice app center , která vysvětluje, jak pro vaši aplikaci poskytnout symboly.
Poznámka
Pokud jste připojeni k ladicímu programu, sada SDK nepředá žádné protokoly chybových ukončení. Ujistěte se, že ladicí program není připojený při chybovém ukončení aplikace.
Poznámka
Pokud chcete přijímat správně symbolická trasování zásobníku, ujistěte se, že je zakázaný bitcode. Další informace o bitcode najdete v dokumentaci k symbolizaci pro iOS v App Center.
Poznámka
4.0.0
Ve verzi App Center byly zavedeny zásadní změny. Pokud chcete migrovat App Center z předchozích verzí, postupujte podle části Migrace na sadu App Center SDK 4.0.0 a vyšší .
App Center podporuje zasílání zpráv o chybách v rozšířeních pro iOS. Využití je stejné jako v aplikaci kontejneru.
Aplikace App Center Crashes poskytuje rozhraní API pro vygenerování testovacího chybového ukončení pro snadné testování sady SDK. Toto rozhraní API se dá použít jenom v testovacích nebo beta aplikacích a v produkčních aplikacích nic neudělá.
[MSACCrashes generateTestCrash];
Crashes.generateTestCrash()
Aplikace App Center Crashes má dvě rozhraní API, která poskytují další informace pro případ, že dojde k chybovému ukončení aplikace.
Kdykoli po spuštění sady SDK můžete zkontrolovat, jestli aplikace obdržela upozornění paměti v předchozí relaci:
[MSACCrashes hasReceivedMemoryWarningInLastSession];
Crashes.hasReceivedMemoryWarningInLastSession
Poznámka
Tuto metodu je možné použít pouze po Crashes
spuštění, vždy se vrátí NO
nebo false
před spuštěním.
Poznámka
V některých případech zařízení s nedostatkem paměti nemůže odesílat události.
Kdykoli po spuštění sady SDK můžete zkontrolovat, jestli aplikace při předchozím spuštění havarovala:
[MSACCrashes hasCrashedInLastSession];
Crashes.hasCrashedInLastSession
To se hodí pro případ, že chcete upravit chování nebo uživatelské rozhraní aplikace po chybovém ukončení.
Poznámka
Tuto metodu je možné použít pouze po MSACCrashes
spuštění, vždy se vrátí NO
nebo false
před spuštěním.
Pokud vaše aplikace dříve havarovala, můžete získat podrobnosti o posledním chybovém ukončení.
MSACErrorReport *crashReport = [MSACCrashes lastSessionCrashReport];
var crashReport = Crashes.lastSessionCrashReport
Poznámka
Tuto metodu je možné použít pouze po Crashes
spuštění, vždy se vrátí nil
před spuštěním.
Pro toto rozhraní API existuje mnoho případů použití. Nejběžnější z nich jsou lidé, kteří toto rozhraní API volají a implementují vlastní crashesDelegate.
Aplikace App Center Crashes poskytuje vývojářům zpětná volání, která mohou provádět další akce před a při odesílání protokolů chyb do App Center.
Chcete-li přidat vlastní chování, musíte přijmout CrashesDelegate
-protocol, všechny jeho metody jsou volitelné.
[MSACCrashes setDelegate:self];
Crashes.delegate = self
Poznámka
Před voláním AppCenter.start
musíte nastavit delegáta, protože App Center začne zpracovávat chybové ukončení hned po spuštění.
Implementujte metodu crashes:shouldProcessErrorReport:
-ve třídě, která přijímá CrashesDelegate
protokol -, pokud chcete rozhodnout, jestli je potřeba zpracovat konkrétní chybu nebo ne. Může například dojít k chybovému ukončení na úrovni systému, které byste chtěli ignorovat a které nechcete posílat do 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.
}
App Center také umožňuje sledovat chyby pomocí zpracovaných výjimek prostřednictvím trackError
metody. Aplikace může volitelně připojit vlastnosti nebo přílohy ke zpracovávané zprávě o chybách, aby poskytla další kontext.
@try {
// Throw error.
} @catch (NSError *error) {
// Init attachments.
NSArray<MSACErrorAttachmentLog *> attachments = @[ MSACErrorAttachmentLog attachmentWithText:@"Hello world!" filename:@"hello.txt"] ]
// Init properties.
NSDictionary *properties = @{ "Category" : "Music", "Wifi" : "On" };
// Track errors.
[MSACCrashes trackError:error withProperties:properties attachments:attachments];
[MSACCrashes trackError:error withProperties:properties attachments:nil];
[MSACCrashes trackError:error withProperties:nil attachments:attachments];
[MSACCrashes trackError:error withProperties:nil attachments:nil];
}
do {
// Throw error.
} catch {
// Init attachments.
let attachments = [ErrorAttachmentLog.attachment(withText: "Hello world!", filename: "hello.txt")]
// Init properties.
let properties:Dictionary<String, String> = ["Category" : "Music", "Wifi" : "On"]
// Track errors.
Crashes.trackError(error, properties: properties, attachments: attachments)
Crashes.trackError(error, properties: properties, attachments: nil)
Crashes.trackError(error, properties: nil, attachments: attachments)
Crashes.trackError(error, properties: nil, attachments: nil)
}
Pro sledování výjimek můžete použít trackException
metodu:
@try {
// Throw exceptions.
} @catch (NSException *exception) {
// Init exceptions.
MSACExceptionModel *customException1 = [MSACExceptionModel initWithType:@"Custom exception" exceptionMessage:"Track custom exception.", stackTrace:exception.callStackSymbols];
MSACExceptionModel *customException2 = [MSACExceptionModel initWithException:exception];
// Track exceptions.
[MSACCrashes trackException:customException1 withProperties:properties attachments:nil];
[MSACCrashes trackException:customException2 withProperties:properties attachments:nil];
}
do {
// Throw exception.
} catch {
// Init exception.
let exception = ExceptionModel(withType: "Custom exception", exceptionMessage: "Track custom exception.", stackTrace: Thread.callStackSymbols)
// Track exception.
Crashes.trackException(exception, properties: properties, attachments: nil)
}
Pokud je pro vás ochrana osobních údajů uživatelů důležitá, můžete před odesláním zprávy o chybovém ukončení do App Center získat potvrzení uživatele. Sada SDK zveřejňuje zpětné volání, které informuje o chybách App Center, aby před odesláním zpráv o chybách čekalo na potvrzení uživatele.
Pokud jste se tak rozhodli, zodpovídáte za získání potvrzení uživatele, například prostřednictvím dialogového okna s jednou z následujících možností: Vždy odeslat, Odeslat a Neodesílat. Na základě vstupu řeknete App Center, co dělat, a pak se s chybovým ukončením odpovídajícím způsobem zpracuje.
Poznámka
V sadě SDK se nezobrazuje dialogové okno, aplikace musí poskytnout vlastní uživatelské rozhraní, aby mohla požádat o souhlas uživatele.
Poznámka
Aplikace by neměla volat notifyWithUserConfirmation
explicitně, pokud neimplementuje dialogové okno pro potvrzení uživatele. Modul Chybové ukončení bude zpracovávat posílání protokolů implicitně za vás.
Následující metoda ukazuje, jak nastavit obslužnou rutinu potvrzení uživatele:
[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.
})
V případě, že se vrátíte YES
/true
v bloku obslužné rutiny výše, měla by vaše aplikace získat oprávnění uživatele a odeslat sadě SDK zprávu s výsledkem pomocí následujícího rozhraní API. Pokud k tomu používáte upozornění, jako to děláme v ukázce výše, volali byste ho z vaší implementace zpětného alertView:clickedButtonAtIndex:
volání .
// 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)
Někdy chcete znát stav chybového ukončení aplikace. Běžným případem použití je, že můžete chtít zobrazit uživatelské rozhraní, které uživatelům oznámí, že vaše aplikace odesílá zprávu o chybovém ukončení, nebo v případě, že aplikace po spuštění rychle padá, chcete upravit chování aplikace, aby bylo možné odesílat protokoly chybových ukončení. Parametr CrashesDelegate
-protocol definuje tři různá zpětná volání, která můžete v aplikaci použít k oznámení o tom, co se děje:
- (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.
}
V případě, že máme problémy se sítí nebo výpadek koncového bodu a restartujete aplikaci, willSendErrorReport
aktivuje se po restartování procesu znovu.
- (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.
}
Pokud se sadě SDK nepodařilo odeslat protokol chybových ukončení, vyvolá se následující zpětné volání.
- (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.
}
Příjem didFailSendingErrorReport
znamená, že došlo k neobnovitelné chybě, například ke kódu 4xx . Například hodnota 401 znamená, že appSecret
je špatná.
Toto zpětné volání se neaktivuje, pokud se jedná o problém se sítí. V tomto případě sada SDK stále opakuje pokusy (a pozastavuje opakování, když je síťové připojení mimo provoz).
Do zprávy o chybovém ukončení můžete přidat binární a textové přílohy. Sada SDK je odešle spolu s chybovým ukončením, abyste je mohli zobrazit na portálu App Center. Následující zpětné volání se vyvolá přímo před odesláním uloženého chybového ukončení z předchozích spuštění aplikace. Když dojde k chybě, nebude vyvolána. Tady je příklad připojení textu a obrázku k chybovému ukončení:
- (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!]
}
Poznámka
Limit velikosti je aktuálně 7 MB. Při pokusu o odeslání větší přílohy dojde k chybě.
Za běhu můžete povolit a zakázat chybové ukončení app center. Pokud ho zakážete, sada SDK nebude pro aplikaci hlásit žádné chybové ukončení.
[MSACCrashes setEnabled:NO];
Crashes.enabled = false
Pokud chcete znovu povolit chybové ukončení App Centeru, použijte stejné rozhraní API, ale předejte YES
/true
ho jako parametr.
[MSACCrashes setEnabled:YES];
Crashes.enabled = true
Stav se v úložišti zařízení během spouštění aplikací udržuje.
Poznámka
Tuto metodu je možné použít pouze po Crashes
spuštění.
Můžete také zkontrolovat, jestli jsou povolená chybová ukončení app center:
BOOL enabled = [MSACCrashes isEnabled];
var enabled = Crashes.enabled
Poznámka
Tuto metodu je možné použít pouze po Crashes
spuštění, vždy se vrátí false
před spuštěním.
Ve výchozím nastavení aplikace App Center crashes používá obslužnou rutinu výjimky Mach k zachycení závažných signálů, například přetečení zásobníku, prostřednictvím serveru výjimek Mach.
Metoda disableMachExceptionHandler
-poskytuje možnost zakázat zachycení závažných signálů prostřednictvím serveru výjimek Mach. Pokud chcete zakázat obslužnou rutinu výjimky Mach, měli byste tuto metodu volat před spuštěním sady SDK. Váš typický instalační kód by vypadal takto:
[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])