Megosztás a következőn keresztül:

Az App Center összeomlik (macOS)

Fontos

A Visual Studio App Center 2025. március 31-én megszűnt, kivéve az Elemzési és diagnosztikai funkciókat, amelyek 2026. június 30-ig továbbra is támogatottak lesznek. Tudj meg többet.

Az App Center összeomlásai automatikusan létrehoznak összeomlási naplót minden alkalommal, amikor az alkalmazás összeomlik. A napló először az eszköz tárolójába lesz beírva, és amikor a felhasználó újra elindítja az alkalmazást, a rendszer elküldi az összeomlási jelentést az App Centernek. Az összeomlások összegyűjtése a bétaverziós és az élő alkalmazások, azaz az App Store-ba küldött alkalmazások esetében is működik. Az összeomlási naplók értékes információkat tartalmaznak az összeomlás elhárításához.

Kövesse az Első lépések szakaszt, ha még nem állította be az SDK-t az alkalmazásban.

Emellett a macOS összeomlási naplóinak szimbolikus megjelenítésére is szükség van, tekintse meg az App Center Diagnostics dokumentációját , amely bemutatja, hogyan adhat szimbólumokat az alkalmazáshoz.

Megjegyzés:

Az App Center 4.0.0 verziójában kompatibilitástörő változások jelentek meg. Kövesse az Áttelepítés az App Center SDK 4.0.0-s és újabb verziójára című szakaszt az App Center korábbi verziókból való áttelepítéséhez.

Összeomlásjelentés bővítményekben

Az App Center támogatja az összeomlási jelentéskészítést a macOS-bővítményekben. A használat ugyanaz, mint a tárolóalkalmazásban.

Készítsen tesztösszeomlást

Az App Center Crashes egy API-t biztosít, amellyel tesztösszeomlást hozhat létre az SDK egyszerű teszteléséhez. Ez az API csak tesztelési/bétaverziós alkalmazásokban használható, és az éles alkalmazásokban semmit sem fog tenni.

[MSACCrashes generateTestCrash];

Crashes.generateTestCrash()

További információ az előző összeomlásról

Az App Center Összeomlások két API-val rendelkezik, amelyek további információt nyújtanak arról, hogy az alkalmazás összeomlott-e.

Az alkalmazás alacsony memóriahasználati figyelmeztetést kapott az előző munkamenetben?

Az SDK elindítása után bármikor ellenőrizheti, hogy az alkalmazás memóriariasztást kapott-e az előző munkamenetben:

[MSACCrashes hasReceivedMemoryWarningInLastSession];

Crashes.hasReceivedMemoryWarningInLastSession

Megjegyzés:

Ezt a metódust csak az indítás után, Crashes, lehet használni; mindig vissza fog térni NO vagy false az indítás előtt.

Megjegyzés:

Bizonyos esetekben a kevés memóriával rendelkező eszköz nem tud eseményeket küldeni.

Összeomlott az alkalmazás az előző munkamenetben?

Az SDK elindítása után bármikor ellenőrizheti, hogy az alkalmazás összeomlott-e az előző indításkor:

[MSACCrashes hasCrashedInLastSession];

Crashes.hasCrashedInLastSession

Ez akkor hasznos, ha az összeomlás után módosítani szeretné az alkalmazás viselkedését vagy felhasználói felületét.

Megjegyzés:

Ezt a metódust csak az indítás után, MSACCrashes, lehet használni; mindig vissza fog térni NO vagy false az indítás előtt.

Az utolsó összeomlás részletei

Ha az alkalmazás korábban összeomlott, részletes információkat kaphat az utolsó összeomlásról.

MSACErrorReport *crashReport = [MSACCrashes lastSessionCrashReport];

var crashReport = Crashes.lastSessionCrashReport

Megjegyzés:

Ezt a metódust csak akkor szabad használni, ha a Crashes már elindult. Mindig visszaad nil a kezdés előtt.

Ehhez az API-hoz számos használati eset létezik, a leggyakoribbak azok, akik ezt az API-t hívják, és implementálják az egyéni CrashesDelegate-et.

Az App Center-összeomlások használatának testreszabása

Az App Center összeomlásai visszahívásokat biztosítanak a fejlesztőknek, hogy további műveleteket hajtsanak végre az összeomlási naplók App Centerbe való küldése előtt és során.

Az egyéni viselkedés hozzáadásához be kell vezetnie a CrashesDelegate-protokollt, minden metódusa nem kötelező.

Regisztráció meghatalmazottként

[MSACCrashes setDelegate:self];

Crashes.delegate = self

Megjegyzés:

A hívás AppCenter.start be kell állítania a meghatalmazottat, mivel az App Center közvetlenül a kezdés után megkezdi az összeomlások feldolgozását.

Fel kell dolgoznunk az összeomlást?

Implementálja a crashes:shouldProcessErrorReport:-metódust abban az osztályban, amely a CrashesDelegate-protokollt alkalmazza, ha el szeretné dönteni, hogy egy adott összeomlást fel kell-e dolgozni vagy sem. Előfordulhat például egy rendszerszintű összeomlás, amelyet figyelmen kívül szeretne hagyni, és amelyet nem szeretne elküldeni az App Centerbe.

- (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.
}

Kezelt hibák

Az App Center lehetővé teszi a hibák nyomon követését is a kezelt kivételek metóduson keresztüli trackError használatával. Az alkalmazások tetszés szerint tulajdonságokat vagy/és mellékleteket csatolhatnak egy kezelt hibajelentéshez, hogy további kontextust biztosítsanak.

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

A nyomkövetési kivételekhez használhatja a trackException módszert.

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

Ha fontos önnek a felhasználói adatvédelem, érdemes lehet a felhasználó megerősítését kapnia, mielőtt összeomlási jelentést küldene az App Centernek. Az SDK biztosít egy visszahívást, amely az App Center Crashes számára jelzi, hogy várjon a felhasználói visszaigazolásra, mielőtt bármilyen összeomlási jelentést küldene.

Ha ezt választotta, ön a felelős a felhasználó megerősítésének beszerzéséért, például egy párbeszédpanelen keresztül, amely a következő lehetőségek egyikét tartalmazza: Mindig küldés, Küldés és Ne küldjön. A bemenet alapján meg fogja mondani az App Center Crashesnek, hogy mit kell tennie, és az összeomlást ennek megfelelően fogja kezelni.

Megjegyzés:

Az SDK ehhez nem jelenít meg párbeszédpanelt, az alkalmazásnak saját felhasználói felületet kell biztosítania a felhasználói hozzájárulás kéréséhez.

A következő módszer bemutatja, hogyan állíthat be felhasználó-megerősítési kezelőt:

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

  // Your code to present your UI to the user, e.g. an NSAlert.
  NSAlert *alert = [[NSAlert alloc] init];
  [alert setMessageText:@"Sorry about that!"];
  [alert setInformativeText:@"Do you want to send an anonymous crash report so we can fix the issue?"];
  [alert addButtonWithTitle:@"Always send"];
  [alert addButtonWithTitle:@"Send"];
  [alert addButtonWithTitle:@"Don't send"];
  [alert setAlertStyle:NSWarningAlertStyle];

  switch ([alert runModal]) {
  case NSAlertFirstButtonReturn:
    [MSACCrashes notifyWithUserConfirmation:MSACUserConfirmationAlways];
    break;
  case NSAlertSecondButtonReturn:
    [MSACCrashes notifyWithUserConfirmation:MSACUserConfirmationSend];
    break;
  case NSAlertThirdButtonReturn:
    [MSACCrashes notifyWithUserConfirmation:MSACUserConfirmationDontSend];
    break;
  default:
    break;
  }

  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 NSAlert.
  let alert: NSAlert = NSAlert()
  alert.messageText = "Sorry about that!"
  alert.informativeText = "Do you want to send an anonymous crash report so we can fix the issue?"
  alert.addButton(withTitle: "Always send")
  alert.addButton(withTitle: "Send")
  alert.addButton(withTitle: "Don't send")
  alert.alertStyle = NSWarningAlertStyle

  switch (alert.runModal()) {
  case NSAlertFirstButtonReturn:
    Crashes.notify(with: .always)
    break;
  case NSAlertSecondButtonReturn:
    Crashes.notify(with: .send)
    break;
  case NSAlertThirdButtonReturn:
    Crashes.notify(with: .dontSend)
    break;
  default:
    break;
  }

  return true // Return true if the SDK should await user confirmation, otherwise return false.
})

Ha a fenti kezelő blokkban visszatér YES/true, az alkalmazásnak felhasználói engedélyt kell szereznie, és az eredménnyel üzenetet kell küldenie az SDK-nak az alábbi API használatával. Ha ehhez riasztást használ, úgy, ahogyan a fenti példában is, akkor a hívást a ModalResponse eredménye alapján indíthatja el.

// Depending on the user'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)

A főszálra kidobott nem merülő kivételek elfogásának engedélyezése

Az AppKit elfogja a főszálra dobott kivételeket, megakadályozva, hogy az alkalmazás összeomlzon macOS rendszeren, így az SDK nem tudja elkapni ezeket az összeomlásokat. Az iOS-viselkedés utánzásához állítsa be a NSApplicationCrashOnExceptions jelzőt az SDK inicializálása előtt. Ez a jelző lehetővé teszi, hogy az alkalmazás összeomoljon a le nem kezelt kivételek miatt, az SDK pedig jelentheti ezeket.

[[NSUserDefaults standardUserDefaults] registerDefaults:@{ @"NSApplicationCrashOnExceptions" : @YES }];

UserDefaults.standard.register(defaults: ["NSApplicationCrashOnExceptions": true])

Megjegyzés:

Az App Center SDK automatikusan beállítja a jelzőt az 1.10.0-s és újabb verziókban. Az 1.11.0-s verziótól kezdve ez a jelző már nem lesz automatikusan beállítva.

Az alkalmazás főosztályának metódushívásainak továbbításának letiltása az App Center Crashes funkcióhoz

Az App Center Crashes SDK az integrációt javítja azáltal, hogy swizzling technikával továbbítja magának az alkalmazás főbb osztályának metódushívásait. A metódus cserélés a metódusok futásidőben történő megvalósításának megváltoztatására használható. Ha valamilyen okból nem szeretné használni a swizzlinget (például egy adott szabályzat miatt), akkor felül kell írnia az alkalmazás reportException: és sendEvent: metódusait annak érdekében, hogy az Összeomlás funkció megfelelően jelentse a fő szálon dobott kivételeket.

  1. Hozza létre a ReportExceptionApplication.m fájlt, és adja hozzá a következő implementációt:

    @import Cocoa;
@import AppCenterCrashes;

@interface ReportExceptionApplication : NSApplication
@end

@implementation ReportExceptionApplication

- (void)reportException:(NSException *)exception {
  [MSACCrashes applicationDidReportException:exception];
  [super reportException:exception];
}

- (void)sendEvent:(NSEvent *)theEvent {
  @try {
    [super sendEvent:theEvent];
  } @catch (NSException *exception) {
    [self reportException:exception];
  }
}

@end

    Megjegyzés:

    try / catch Swift nem működik együtt NSException-val. Ezek a kivételek kizárólag Objective-C-ban kezelhetők.

  2. Nyissa meg az Info.plist fájlt, és cserélje le az Egyszerű osztály mező NSApplication elemét az alkalmazásosztály nevére, ebben a példában a ReportExceptionApplication névre.

  3. Az App Center SDK-ban történő swizzling letiltásához adjon hozzá egy kulcsot az AppCenterApplicationForwarderEnabled fájlhoz, és állítsa be az értéket .

Információk az összeomlási napló küldési állapotáról

Időnként tudni szeretné az alkalmazás összeomlásának állapotát. Gyakori használati eset, hogy olyan felhasználói felületet szeretne megjeleníteni, amely tájékoztatja a felhasználókat arról, hogy az alkalmazás összeomlási jelentést küld, vagy ha az alkalmazás az indítás után gyorsan összeomlik, módosítania kell az alkalmazás viselkedését, hogy az összeomlási naplók elküldhetők legyenek. A CrashesDelegate-protocol három különböző visszahívást határoz meg, amelyeket az alkalmazásban használhat, hogy értesüljön a történtekről:

A rendszer a következő visszahívást hívja meg, mielőtt az SDK összeomlási naplót küld

- (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.
}

Ha hálózati problémák vagy kimaradás lép fel a végponton, és újraindítja az alkalmazást, willSendErrorReport a folyamat újraindítása után újra aktiválódik.

A rendszer az alábbi visszahívást fogja meghívni, miután az SDK sikeresen elküldte az összeomlási naplót

- (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.
}

A rendszer a következő visszahívást hívja meg, ha az SDK nem tudott összeomlási naplót küldeni

- (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.
}

A(z) didFailSendingErrorReport azt jelenti, hogy nem helyreállítható hiba, például egy 4xx kód történt. Például a 401 azt jelenti, hogy a appSecret helytelen.

Ez a visszahívás hálózati probléma esetén nem aktiválódik. Ebben az esetben az SDK folytatja az újrapróbálkozást (és szünetelteti az újrapróbálkozást, amíg a hálózati kapcsolat leáll).

Összeomlási jelentéshez mellékletek hozzáadása

Bináris és szöveges mellékleteket is hozzáadhat az összeomlási jelentésekhez. Az SDK az összeomlással együtt küldi el őket, hogy megjelenjenek az App Center portálon. A rendszer a következő visszahívást fogja meghívni, mielőtt elküldené a tárolt összeomlást az előző alkalmazásindításokból. Az összeomlás bekövetkezésekor a rendszer nem fogja meghívni. Íme egy példa arra, hogyan csatolhat szöveget és képet egy hibajelenséghez.

- (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!]
}

Megjegyzés:

A méretkorlát jelenleg 7 MB. Ha nagyobb mellékletet kísérel meg elküldeni, hiba lép fel.

Az App Center futásidejű összeomlásainak engedélyezése vagy letiltása

Futásidőben engedélyezheti és letilthatja az App Center összeomlás funkcióját. Ha letiltja, az SDK nem végez összeomlási jelentést az alkalmazáshoz.

[MSACCrashes setEnabled:NO];

Crashes.enabled = false

Az App Center összeomlásainak újbóli engedélyezéséhez használja ugyanazt az API-t, de adjon át YES/true paraméterként.

[MSACCrashes setEnabled:YES];

Crashes.enabled = true

Az állapot megmarad az eszköz tárolójában az alkalmazásindítások során.

Megjegyzés:

Ezt a módszert csak akkor szabad használni, ha a Crashes már elindult.

Ellenőrizze, hogy engedélyezve van-e az App Center Crashes funkciója

Azt is ellenőrizheti, hogy engedélyezve van-e az App Center Crashes:

BOOL enabled = [MSACCrashes isEnabled];

var enabled = Crashes.enabled

Megjegyzés:

Ezt a metódust csak akkor szabad használni, ha a Crashes már elindult. Mindig visszaad false a kezdés előtt.

A Mach kivételkezelésének letiltása

Az App Center Crashes alapértelmezés szerint a Mach kivételkezelővel észleli a végzetes jeleket, például a verem túlcsordulásait egy Mach kivételkiszolgálón keresztül.

A disableMachExceptionHandler-metódus lehetővé teszi a halálos jelek elfogásának letiltását egy Mach kivételkiszolgálón keresztül. Ha le szeretné tiltani a Mach kivételkezelőt, az SDK elindítása előtt hívja meg ezt a metódust. A tipikus beállítási kód a következőképpen nézne ki:

[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])
  • Last updated on