Simboleggia i rapporti sugli arresti anomali dell'app per iPhone

https://stackoverflow.com/questions/1460892

13-09-2019
|

Domanda

Sto cercando di simbolizzare i rapporti sugli arresti anomali della mia app per iPhone.

Ho recuperato i rapporti sugli arresti anomali da iTunes Connect.Ho il file binario dell'applicazione che ho inviato all'App Store e il file dSYM che è stato generato come parte della build.

Ho tutti questi file insieme all'interno di un'unica directory indicizzata da Spotlight.

E adesso?

Ho provato a invocare:

symbolicatecrash crashreport.crash myApp.app.dSYM

e restituisce semplicemente lo stesso testo presente nel rapporto sull'arresto anomalo con cui iniziare, non simbolizzato.

Sto facendo qualcosa di sbagliato?

Soluzione

Passaggi per analizzare il rapporto sugli arresti anomali di Apple:

Copia il file .app della versione che è stato inviato all'appstore, il file .dSYM creato al momento del rilascio e il rapporto sugli arresti anomali ricevuto da APPLE in un CARTELLA.
APRI l'applicazione terminale e vai alla cartella creata sopra (utilizzando cd comando)
Correre atos -arch armv7 -o APPNAME.app/APPNAME MEMORY_LOCATION_OF_CRASH.La posizione della memoria dovrebbe essere quella in cui l'app si è arrestata in modo anomalo secondo il rapporto.

Ex: atos -arch armv7 -o 'APPNAME.app'/'APPNAME' 0x0003b508

Questo mostrerebbe la riga esatta e il nome del metodo che ha provocato l'arresto anomalo.

Ex: [classname functionName:]; -510

Simboleggia l'IPA

se utilizziamo IPA per la simbolizzazione, basta rinominare l'estensione .ipa con .zip, estrarla, quindi possiamo ottenere una cartella di payload che contiene l'app.In questo caso non abbiamo bisogno del file .dSYM.

Nota

Questo può funzionare solo se il file binario dell'app non ha simboli rimossi.Per impostazione predefinita, le build di rilascio hanno rimosso i simboli.Possiamo modificarlo nelle impostazioni di creazione del progetto "Rimuovi simboli di debug durante la copia" su NO.

Maggiori dettagli vedere questo inviare

Altri suggerimenti

Dopo aver letto tutte queste risposte qui, al fine di symbolicate un crash log (e finalmente riuscendo) Penso che ci sono alcuni punti mancanti qui che sono realmente importanti per determinare il motivo per cui l'invocazione di symbolicatecrash non produce un'uscita symbolicated.

Ci sono 3 le attività che hanno per adattarsi insieme quando symbolicating un crash log:

Il file di log incidente in sé (vale a dire example.crash), sia esportati da Organizzatore XCode o ricevuto da iTunes Connect.
Il pacchetto .app (vale a dire example.app) che si contiene il binario di applicazione appartenente al registro dei crash. Se si dispone di un pacchetto di .ipa (vale a dire example.ipa) allora si può estrarre il pacchetto .app da decomprimere il pacchetto .ipa (vale a dire unzip example.ipa). Successivamente il pacchetto .app risiede nella cartella estratta Payload/.
Il pacchetto .dSYM contenente i simboli di debug (cioè example.app.dSYM)

Prima di iniziare symbolication si dovrebbe verificare se tutti quei manufatti corrispondono, il che significa che il crash log appartiene al binario che hai e che i simboli di debug sono quelli prodotti durante la costruzione di quel binario.

Ogni binario viene indicato da un UUID che può essere visto nel file di registro dei crash:

...
Binary Images:
0xe1000 -    0x1f0fff +example armv7  <aa5e633efda8346cab92b01320043dc3> /var/mobile/Applications/9FB5D11F-42C0-42CA-A336-4B99FF97708F/example.app/example
0x2febf000 - 0x2fedffff  dyld armv7s  <4047d926f58e36b98da92ab7a93a8aaf> /usr/lib/dyld
...

In questo estratto il crash log appartiene ad un'immagine binaria applicazione denominata example.app/example con UUID aa5e633efda8346cab92b01320043dc3.

È possibile controllare l'UUID del pacchetto binario che hai con dwarfdump:

dwarfdump --uuid example.app/example
UUID: AA5E633E-FDA8-346C-AB92-B01320043DC3 (armv7) example.app/example

In seguito si dovrebbe verificare se i simboli di debug si hanno anche appartengono a quel binario:

dwarfdump --uuid example.app.dSYM
UUID: AA5E633E-FDA8-346C-AB92-B01320043DC3 (armv7) example.app.dSYM/Contents/Resources/DWARF/example

In questo esempio, tutte le attività si incastrano e si dovrebbe essere in grado di symbolicate vostro stacktrace.

Procedendo allo script symbolicatecrash:

In Xcode 8.3 si dovrebbe essere in grado di richiamare lo script tramite

/Applications/Xcode.app/Contents/SharedFrameworks/DVTFoundation.framework/Versions/A/Resources/symbolicatecrash -v example.crash 2> symbolicate.log

Se non è ci si può incorrere un find . -name symbolicatecrash nella directory Xcode.app per trovarlo.

Come potete vedere non ci sono più parametri dati. Quindi lo script deve trovare il binario delle applicazioni e simboli di debug eseguendo una ricerca Spotlight. Cerca i simboli di debug con un indice specifico chiamato com_apple_xcode_dsym_uuids. Si può fare questa ricerca da soli:

mdfind 'com_apple_xcode_dsym_uuids = *'

risp.

mdfind "com_apple_xcode_dsym_uuids == AA5E633E-FDA8-346C-AB92-B01320043DC3"

La prima invocazione riflettori ti dà tutti i pacchetti dSYM indicizzati e la seconda ti dà i pacchetti .dSYM con un UUID specifica. Se riflettori non trova il pacchetto .dSYM poi symbolicatecrash sarà nessuno dei due. Se fai tutte queste cose per esempio in una sottocartella della vostra riflettori ~/Desktop dovrebbe essere in grado di trovare tutto.

Se symbolicatecrash trova il pacchetto .dSYM ci dovrebbe essere una linea come la seguente in symbolicate.log:

@dsym_paths = ( <SOME_PATH>/example.app.dSYM/Contents/Resources/DWARF/example )

Per trovare il vostro pacchetto .app una ricerca Spotlight come il seguente viene invocato da symbolicatecrash:

mdfind "kMDItemContentType == com.apple.application-bundle && (kMDItemAlternateNames == 'example.app' || kMDItemDisplayName == 'example' || kMDItemDisplayName == 'example.app')"

Se symbolicatecrash trova il pacchetto .app ci dovrebbe essere il seguente estratto in symbolicate.log:

Number of symbols in <SOME_PATH>/example.app/example: 2209 + 19675 = 21884
Found executable <SOME_PATH>/example.app/example
-- MATCH

Se tutte quelle risorse si trovano per symbolicatecrash si deve stampare la versione symbolicated del registro blocchi.

Se non è possibile passare nella vostra dSYM e direttamente i file .app.

symbolicatecrash -v --dsym <SOME_PATH>/<App_URI>.app.dSYM/<APP_NAME>.app.dsym <CRASHFILE> <SOME_OTHER_PATH>/<APP_NAME>.app/<APP_NAME> > symbolicate.log

Nota. Il backtrace symbolicated viene emesso al morsetto, non symbolicate.log

Con l'ultima versione di Xcode (3.2.2), è possibile trascinare e rilasciare eventuali segnalazioni di crash nella sezione registri dei dispositivi della Xcode Organizer e saranno automaticamente symbolicated per voi. Credo che questo funziona meglio se hai costruito quella versione di App usando costruire & Archive (anche parte di Xcode 3.2.2)

L'ho fatto con successo, utilizzando la seguente procedura.

Passaggio 1: Creare una cartella nella scrivania, ho dato il nome a "CrashReport" e messo tre file ( "MYApp.app", "MyApp.app.dSYM", "MYApp_2013-07 -18.crash ") in esso.

Passaggio 2: Apri Finder e andate su Applicazioni, dove si trova l'applicazione Xcode, fate clic destro su questo e fare clic su "Mostra contenuto pacchetto", dopo questo seguire questo semplice percorso. "Contents-> Developer-> piattaforme-> iPhoneOS.platform-> Developer->> Library- PrivateFrameworks -> DTDeviceKit.framework -> versioni-> A-> Risorse"

"Contents-> Developer-> piattaforme-> iPhoneOS.platform-> Developer->> Library- PrivateFrameworks -> DTDeviceKitBase.framework -> versioni-> A-> Risorse"

Per Xcode 6 e sopra il percorso è Applicazioni / Xcode.app / Contents / SharedFrameworks / DTDeviceKitBase.framework / Versions / A / Resources

Dove si trova il file "symbolicatecrash", copiare questo e incollarlo nella cartella "CrashReport".

Passaggio 3: avviare il terminale, eseguire questi 3 Comando

cd / Users / mac38 / Desktop / CrashReport e premere Invio pulsante
esportazione DEVELOPER_DIR = "/ Applications / Xcode.app / Contents / developer" e premere Invio
./ symbolicatecrash -A -v MYApp_2013-07-18.crash MyApp.app.dSYM e premere Invio Ora i suoi fatto .. (Nota: le versioni in tutto 6.4 o successiva non hanno l'opzione -A - basta lasciare out).

Procedura per symbolicate una relazione crash automaticamente utilizzando XCode:

aggiornato per XCODE 9

Connetti qualsiasi dispositivo iOS al Mac (sì uno fisico, sì, so che questo è stupido)
Scegli "Dispositivi" dal menu "Finestra"
Fare clic sul proprio dispositivo sui registri dei dispositivi di sinistra e di vista sulla destra
Wait. Si potrebbe prendere un minuto per presentarsi. Magari facendo Command-A poi Delete sarà accelerare l'operazione.
passo senza documenti Critico: rinominare la segnalazione di crash che avete ottenuto da iTunesConnect dall'estensione .txt a .crash estensione
Trascinare il report crash in quella zona a sinistra

E poi Xcode sarà symbolicate la segnalazione di crash e visualizzare i risultati.

Fonte: https://developer.apple.com/library/ ios / note tecniche / tn2151 / _index.html

Io uso Airbrake nelle mie applicazioni, che fa un lavoro abbastanza buono di registrazione degli errori a distanza.

Ecco come li ho symbolicate con Atos se il backtrace ne ha bisogno:

In Xcode (4.2) vanno agli organizzatori, fare clic destro sul archivio da quale è stato generato il file .ipa.
In Terminal, cd nella xcarchive per esempio MyCoolApp 10-27-11 1.30 PM.xcarchive
Immettere il seguente atos -arch armv7 -o 'MyCoolApp.app'/'MyCoolApp' (Non dimenticare le virgolette singole)
Non includo il mio simbolo in quella chiamata. Quello che si ottiene è un cursore di blocco su una riga vuota.
Poi mi copia / incolla il mio codice simbolo in quel cursore di blocco e premere accedere. Vedrai qualcosa di simile:

-[MyCoolVC dealloc] (in MyCoolApp) (MyCoolVC.m:34)
Sei tornato a un cursore di blocco e si può incollare in altri simboli.

Essere in grado di passare attraverso la vostra backtrace una voce senza immettere nuovamente il primo bit è un bel risparmio di tempo.

Enjoy!

Ho anche messo dsym, app fascio, e registro blocchi insieme nella stessa directory prima di eseguire incidente symbolicate

Poi Io uso questa funzione definita nel mio .profile per semplificare l'esecuzione symbolicatecrash:

function desym
{
    /Developer/Platforms/iPhoneOS.platform/Developer/Library/PrivateFrameworks/DTDeviceKit.framework/Versions/A/Resources/symbolicatecrash -A -v $1 | more
}

Gli argomenti aggiunti ci può aiutare.

È possibile controllare per assicurarsi riflettori "vede" i file dysm eseguendo il comando:

mdfind 'com_apple_xcode_dsym_uuids = *'

Cercare il dsym avete nella vostra directory.

NOTA: A partire dalla più recente Xcode, non c'è più una directory Developer. È possibile trovare questo programma di utilità qui:

/Applications/Xcode.app/Contents/SharedFrameworks/DTDeviceKitBase.framework/Vers ioni / A / Resources / symbolicatecrash

Solo una risposta semplice e aggiornata per xcode 6.1.1.

PASSI

1.Xcode>Finestra>Dispositivi.

2.Selezionare un dispositivo da un elenco di dispositivi nella sezione DISPOSITIVI.

3.Selezionare Visualizza registri dispositivo.

4.Nella sezione Tutti i registri è possibile trascinare direttamente il file report.crash

5.Xcode simboleggerà automaticamente il rapporto sugli arresti anomali per te.

6.Puoi trovare il rapporto sull'arresto anomalo simbolico facendo corrispondere la sua data/ora con la data/ora menzionata nel rapporto sull'arresto anomalo.

Anche se fossi stato lo sviluppo di applicazioni per alcuni anni ormai, questa è stata la mia prima volta il debug di un binario e mi sentivo come un NOOB completa capire dove tutti i file sono stati cioè dove è * .app * .dSYM e di crash log ? Ho dovuto leggere più post per capirlo. Un'immagine vale più di mille parole e spero che questo post aiuta chiunque altro in futuro.

1- prima andare a iTunesConnect e scaricare i log di crash. NOTA: E 'maggior parte dei casi si possono ottenere qualcosa di simile a "Troppo pochi rapporti sono stati presentati per una relazione che sarà mostrato." In sostanza non sufficiente di utenti hanno presentato i rapporti del ceppo incidente ad Apple, nel qual caso non si può fare molto di nulla in quel punto.

entrare descrizione dell'immagine qui

2- Ora, se tu non avessi cambiato il codice da quando si era presentato il vostro binario ad Apple poi lanciare Xcode per quel progetto e fare del prodotto -> Archivio di nuovo. In caso contrario, trovare il proprio ultimo presentato binario e fare clic destro su di esso.

entrare descrizione dell'immagine qui

In Xcode 4.2.1, aperto Organizer , poi vai a Registri Library / dispositivo e trascinare il file .crash nella lista dei log di crash. Sarà symbolicated per voi dopo pochi secondi.

Si noti che è necessario utilizzare la stessa istanza di Xcode che l'accumulo originale è stata archiviata sul (vale a dire l'archivio per la build deve esistere in Organizer ).

Utilizzando Xcode 4, il compito è ancora più semplice:

open Organizer ,
cliccare su Biblioteca | Dispositivo Log nella colonna di sinistra
Fare clic su " Importa" pulsante nella parte inferiore dello schermo ...

e voilà. Il file di registro viene importato e simbolizzato automaticamente per voi. A patto di archiviata costruito utilizzando Xcode -> prodotti -.> Archivio prima

Il magico Xcode Organizzatore non è che di magico symbolicating mio app. Ho avuto nessun simbolo a tutti per le segnalazioni di crash che sono tornato da Apple da un app inviata fallito.

Ho provato ad utilizzare la linea di comando, mettendo il relazione crash nella stessa cartella del file .app (che ho presentato al negozio) e il file .dSYM:

$ symbolicatecrash "My App_date_blahblah-iPhone.crash" "My App.app"

Questo solo fornite simboli per la mia app e non il codice nucleo fondante, ma era meglio che la discarica numero che Organizzatore mi sta dando e era abbastanza per me per trovare e risolvere l'incidente che ha avuto la mia app. Se qualcuno sa come estendere questo per ottenere i simboli della Fondazione sarebbe apprezzato.

Nel mio caso, mi trascinavo segnalazioni di crash direttamente da Mail per l'Organizzatore. Per qualche ragione, che ha impedito le segnalazioni di crash da ottenere symbolicated (mi piacerebbe sapere perché).

Copia le segnalazioni di crash al desktop prima, e poi trascinandoli da lì per l'organizzatore ha ottenuto li symbolicated correttamente.

caso molto specifico, lo so. Ma ho pensato di condividere ogni evenienza.

Ecco un altro problema che ho con symbolicatecrash - non funzionerà con le applicazioni che hanno gli spazi nella loro fascio (vale a dire 'Test App.app'). Nota Non credo che si può avere gli spazi nel loro nome al momento della presentazione così si dovrebbe rimuovere questi in ogni caso, ma se si dispone già di arresti che hanno bisogno di analisi, di patch symbolicatecrash (4.3 GM) in quanto tale:

240c240
<         my $cmd = "mdfind \"kMDItemContentType == com.apple.application-bundle && kMDItemFSName == $exec_name.app\"";
---
>         my $cmd = "mdfind \"kMDItemContentType == com.apple.application-bundle && kMDItemFSName == '$exec_name.app'\"";
251c251
<             my $cmd = "find \"$archive_path/Products\" -name $exec_name.app";
---
>             my $cmd = "find \"$archive_path/Products\" -name \"$exec_name.app\"";

Per coloro che utilizzano Airbrake, c'è una risposta solida sopra, ma non avrebbe funzionato per me senza tweaking:

Opere per alcuni indirizzi di memoria ma non altri, non so perché ...

Crea nuovo dir sul desktop o dovunque
Trova archivio in questione in Xcode organizzatore
Doppio tap per rivelare nel Finder
Doppio tap per mostrare il contenuto del bundle
file Copia .dSYM e il file .app nella nuova directory
cd nella nuova directory
Eseguire questo comando: Atos -arch ARMv7 -o 'Vimeo.app' / 'Vimeo'
Terminale entrerà un movimento interattivo
Incolla in indirizzi di memoria e premere Invio, sarà il nome del metodo di uscita e numero di riga
In alternativa, inserire il seguente comando: Atos -arch ARMv7 -o 'Vimeo.app' / 'Vimeo' Per ottenere informazioni per un solo indirizzo

La combinazione che ha funzionato per me è stato:

Copiare il file dSYM nella directory in cui la relazione crash era
Decomprimere il file IPA contenente l'applicazione ( 'MyApp.ipa unzip')
Copiare il file binario applicazione dal payload esploso risultante nella stessa cartella del report di crash e file di simboli (qualcosa come "MyApp.app/MyApp")
Importa o ri-symbolicate la relazione crash dall'interno Organizzatore Xcode

Utilizzo di Atos non ero in grado di risolvere le informazioni simbolo corretto con gli indirizzi e gli offset che erano nel crash report. Quando ho fatto questo, vedo qualcosa di più significativo, e sembra essere una traccia dello stack legittima.

ho dovuto fare un sacco di hacking del sceneggiatura symbolicatecrash per farlo funzionare correttamente.

Per quanto posso dire, symbolicatecrash in questo momento richiede l'.app di essere nella stessa directory del .dsym. Si utilizzerà il .dsym per individuare il .app, ma non utilizzerà il dsym per trovare i simboli.

Si dovrebbe fare una copia del vostro symbolicatecrash prima di provare queste patch che renderà lo sguardo nel dsym:

Nella linea 212 nella funzione getSymbolPathFor_dsymUuid

212     my @executablePath = grep { -e && ! -d } glob("$dsymdir" . "/Contents/Resources/DWARF/" . $executable);

Nella linea 265 nella funzione matchesUUID

265             return 1;

Questo è semplice, dopo aver cercato molto ho trovato passaggi chiari per simbolizzare l'intero file di registro degli arresti anomali.

copiare i file .app, crash_report e DSYM in una cartella.
collega il dispositivo con xcode
Quindi vai alla finestra -> seleziona dispositivi -> visualizza i registri del dispositivo
Quindi seleziona questo dispositivo, elimina tutti i registri.
trascina e rilascia l'arresto anomalo nella sezione del registro del dispositivo.simboleggerà automaticamente lo schianto.basta fare clic con il pulsante destro del mouse sul rapporto ed esportarlo.

felice codifica,
Riyaz

Io preferisco un lo script che symbolicate tutti i miei log di crash.

Presupposti

Create una cartella e messo lì 4 cose:

symbolicatecrash perl sceneggiatura - ci sono molti SO risposte che racconta la sua posizione
L'archivio della build che corrispondono il crash (da Xcode Organizer. Semplice come Show in Finder e copia) [non lo faccio sicuro che questo è necessery]
Tutti i pacchetti xccrashpoint - (. Da Xcode Organizer Show in Finder, è possibile copiare tutti i pacchetti nella directory, o il singolo xccrashpoint volete symbolicate)

Aggiungi che breve script alla directory:

#!/bin/sh

echo "cleaning old crashes from directory"
rm -P *.crash
rm -P *.xccrashpoint
rm -r allCrashes
echo "removed!"
echo ""
echo "--- START ---"
echo ""

mkdir allCrashes
mkdir symboledCrashes
find `ls -d *.xccrashpoint` -name "*.crash" -print -exec cp {} allCrashes/ \;

cd allCrashes
for crash in *.crash; do
    ../symbolicatecrash $crash > ../symboledCrashes/V$crash
done
cd ..

echo ""
echo "--- DONE ---"
echo ""

The Script

Quando si esegue lo script, si otterrà 2 directory.

allCrashes -. Tutti i crash di tutto il xccrashpoint sarà lì
symboledCrashes - gli stessi crash, ma ora con tutti i simboli
non è necessario per pulire la directory da vecchi si blocca prima di eseguire lo script. si pulisce automaticamente. buona fortuna!

Al fine di symbolicate crash, Spotlight deve essere in grado di trovare il file .dSYM che è stato generato allo stesso tempo il binario hai inviato ad Apple era. Dal momento che contiene le informazioni sui simboli, sarete fuori di fortuna, se non è disponibile.

Ho avuto un po 'burbero sul fatto nulla qui sembra "solo lavoro" così ho fatto qualche indagine e il risultato è:

Configurazione: QuincyKit back-end che riceve i rapporti. No symbolication istituito come non ho potuto anche cominciare a capire cosa stessero suggerendo lo faccio per farlo funzionare.

La correzione: scaricare di crash report dal server online. Si chiamano 'incidente' e per impostazione predefinita vanno nella cartella / ~ / Downloads. Con questo in mente, questo script "fare la cosa giusta" e le segnalazioni di crash andrà in Xcode (Organizer, registri dei dispositivi) e symbolication sarà fatto.

Lo script:

#!/bin/bash
# Copy crash reports so that they appear in device logs in Organizer in Xcode

if [ ! -e ~/Downloads/crash ]; then 
   echo "Download a crash report and save it as $HOME/Downloads/crash before running this script."
   exit 1
fi

cd ~/Library/Logs/CrashReporter/MobileDevice/
mkdir -p actx # add crash report to xcode abbreviated
cd actx

datestr=`date "+%Y-%m-%d-%H%M%S"`

mv ~/Downloads/crash "actx-app_"$datestr"_actx.crash"

Le cose possono essere automatizzati al punto in cui è possibile trascinare e rilasciare in Xcode Organizer facendo due cose se si fa uso QuincyKit / PLCR.

In primo luogo, è necessario modificare il telecomando lo script admin / actionapi.php ~ linea 202. Non sembra per ottenere il giusto timestamp, in modo che il file termina con il nome 'Crash', che Xcode non riconosce ( vuole incidente qualcosa dot):

header('Content-Disposition: attachment; filename="crash'.$timestamp.'.crash"');

In secondo luogo, nel lato iOS in QuincyKit BWCrashReportTextFormatter.m ~ linea 176, il cambiamento @"[TODO]" per @"TODO" per aggirare i personaggi cattivi.

Atos è in fase di deprecato quindi se si esegue OSX 10.9 o poi potrebbe essere necessario eseguire

xcrun atos

Attenzione: / usr / bin / Atos è in movimento e sarà rimosso da un futuro sistema operativo X rilascio. E 'ora disponibile negli strumenti di sviluppo Xcode di essere invocato via: xcrun atos

Mi piace usare TextWrangler per individuare gli errori in un app originale caricare il rifiuto binario. (I dati di arresto si trovano nel tuo account iTunesConnect.) Usando il metodo di Sachin sopra copio l'original.crash a TextWrangler, quindi copiare il file symbolicatecrash ho creato un altro file TextWrangler. Confrontando i due file individua differenze. Il file symbolicatecrash avrà differenze che indicano il numero di file e la linea di problemi.

ho scoperto la maggior parte delle alternative proposte non ha funzionato nell'ultimo XCode (testato con Xcode 10). Per esempio, ho avuto fortuna il drag-drop tronchi .crash in Xcode -> Organizzatore -.> Registri dei dispositivi -view

Mi consiglia di utilizzare Symbolicator strumento https://github.com/agentsim/Symbolicator

git clone repository Symbolicator e compilare ed eseguire con Xcode
Copiare il file .crash (file ASCII, con analisi dello stack in accattonaggio di file) e .xarchive di schiantarsi al rilascio stesso temporaneamente cartella
Trascina e rilascia .crash file Symbolicator icona nel Dock
In 5-30 secondi file di dettagli arresto symbolicated è prodotta in stessa cartella .crash e .xarchive sono

Usiamo Google Crashlytics per supervisionare i log di crash, la sensazione è di grande attualità e comodo da usare.

collegamenti di documenti: https://docs.fabric.io/apple/crashlytics/ missing-dsyms.html # missing-dsyms

Tutto su dSYMs mancanti Fabric include uno strumento per caricare automaticamente dSYM del progetto. Lo strumento viene eseguito attraverso lo script / run, che viene aggiunto al vostro Phase Run script di build durante il processo di acquisizione dei. Ci possono essere alcune situazioni tuttavia, quando arrivi dSYM falliscono a causa di configurazioni di progetto unici o se si sta utilizzando codice binario che nella vostra applicazione. Quando un caricamento non riesce, Crashlytics non è in grado di symbolicate e crash di visualizzazione, e apparirà un avviso di “Missing dSYM” sul cruscotto tessuto.

dSYMs mancanti possono essere caricati manualmente seguendo la procedura descritta di seguito.

Nota: In alternativa allo strumento automatizzato di upload dSYM, tessuto fornisce uno strumento da riga di comando (Carica-simboli)) che può essere configurato manualmente per l'esecuzione come parte del processo di creazione del progetto. Vedere la sezione di upload-simboli sotto per le istruzioni di configurazione.

...

Autorizzato sotto: CC-BY-SA insieme a attribuzione

Non affiliato a StackOverflow