Come ottengo i dati di arresto anomalo dalla mia applicazione Android?


737

Come posso ottenere i dati sugli arresti anomali (almeno tracce dello stack) dalla mia applicazione Android? Almeno quando lavoro sul mio dispositivo viene recuperato via cavo, ma idealmente da qualsiasi istanza della mia applicazione in esecuzione in modo da poterlo migliorare e renderlo più solido.


10
Dai
Tom

Vedo che questo invia il rapporto a un server remoto. Può anche registrare l'eccezione in un file locale?

1
Rapporto crash dell'applicazione per Android code.google.com/p/acra
gdonald

Questo sembra essere il più robusto, e se il caricamento dei rapporti non riesce dopo tutti i tentativi, può quindi registrarlo file o sqlite db?
JPM,

Risposte:


354

Puoi provare la libreria ACRA (Application Crash Report per Android) :

ACRA è una libreria che consente all'applicazione Android di pubblicare automaticamente i rapporti sugli arresti anomali in un modulo GoogleDoc. È rivolto agli sviluppatori di applicazioni Android per aiutarli a ottenere dati dalle loro applicazioni quando si bloccano o si comportano in modo errato.

È facile da installare nella tua app, altamente configurabile e non richiede di ospitare uno script del server ovunque ... i rapporti vengono inviati a un foglio di calcolo di Google Doc!


8
È facile da configurare e utilizzare. Consigliato per l'utilizzo prima del mercato e forse anche dopo.
mxcl,

1
Ho iniziato a usarlo ed è incommensurabilmente migliore della segnalazione di errori in Flurry che avevo prima o di quella fatta in casa con cui ho iniziato. Finora, sono entusiasta di "acra".
Adrian Spinei,

8
Il grande vantaggio di acra è la possibilità di utilizzare le API di Google per analizzare e visualizzare facilmente i dati, vedere jberkel.github.com/sms-backup-plus/acra-analysis per un esempio su come eseguire questa operazione.
Jan Berkel,

3
Sembra molto instabile per me. L'ACRA stesso si è arrestato in modo anomalo e ha inviato un rapporto sugli arresti anomali relativo a se stesso, non al relativo arresto anomalo dell'app. -1
Sandor,

19
Google Documenti come backend non è più supportato
eliocs

305

Per applicazioni di esempio e scopi di debug, utilizzo una soluzione semplice che mi consente di scrivere lo stacktrace sulla scheda SD del dispositivo e / o caricarlo su un server. Questa soluzione è stata ispirata da Project android-remote-stacktrace (in particolare, le parti di salvataggio su dispositivo e upload su server) e penso che risolva il problema menzionato da Soonil. Non è ottimale, ma funziona e puoi migliorarlo se vuoi usarlo in un'applicazione di produzione. Se decidi di caricare gli stack stack sul server, puoi utilizzare uno script php ( index.php) per visualizzarli. Se sei interessato, puoi trovare tutte le fonti di seguito: una classe java per la tua applicazione e due script php opzionali per il server che ospita gli stack stack caricati.

In un contesto (ad es. L'attività principale), chiamare

if(!(Thread.getDefaultUncaughtExceptionHandler() instanceof CustomExceptionHandler)) {
    Thread.setDefaultUncaughtExceptionHandler(new CustomExceptionHandler(
            "/sdcard/<desired_local_path>", "http://<desired_url>/upload.php"));
}

CustomExceptionHandler

public class CustomExceptionHandler implements UncaughtExceptionHandler {

    private UncaughtExceptionHandler defaultUEH;

    private String localPath;

    private String url;

    /* 
     * if any of the parameters is null, the respective functionality 
     * will not be used 
     */
    public CustomExceptionHandler(String localPath, String url) {
        this.localPath = localPath;
        this.url = url;
        this.defaultUEH = Thread.getDefaultUncaughtExceptionHandler();
    }

    public void uncaughtException(Thread t, Throwable e) {
        String timestamp = TimestampFormatter.getInstance().getTimestamp();
        final Writer result = new StringWriter();
        final PrintWriter printWriter = new PrintWriter(result);
        e.printStackTrace(printWriter);
        String stacktrace = result.toString();
        printWriter.close();
        String filename = timestamp + ".stacktrace";

        if (localPath != null) {
            writeToFile(stacktrace, filename);
        }
        if (url != null) {
            sendToServer(stacktrace, filename);
        }

        defaultUEH.uncaughtException(t, e);
    }

    private void writeToFile(String stacktrace, String filename) {
        try {
            BufferedWriter bos = new BufferedWriter(new FileWriter(
                    localPath + "/" + filename));
            bos.write(stacktrace);
            bos.flush();
            bos.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private void sendToServer(String stacktrace, String filename) {
        DefaultHttpClient httpClient = new DefaultHttpClient();
        HttpPost httpPost = new HttpPost(url);
        List<NameValuePair> nvps = new ArrayList<NameValuePair>();
        nvps.add(new BasicNameValuePair("filename", filename));
        nvps.add(new BasicNameValuePair("stacktrace", stacktrace));
        try {
            httpPost.setEntity(
                    new UrlEncodedFormEntity(nvps, HTTP.UTF_8));
            httpClient.execute(httpPost);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

upload.php

<?php
    $filename = isset($_POST['filename']) ? $_POST['filename'] : "";
    $message = isset($_POST['stacktrace']) ? $_POST['stacktrace'] : "";
    if (!ereg('^[-a-zA-Z0-9_. ]+$', $filename) || $message == ""){
        die("This script is used to log debug data. Please send the "
                . "logging message and a filename as POST variables.");
    }
    file_put_contents($filename, $message . "\n", FILE_APPEND);
?>

index.php

<?php
    $myDirectory = opendir(".");
    while($entryName = readdir($myDirectory)) {
        $dirArray[] = $entryName;
    }
    closedir($myDirectory);
    $indexCount = count($dirArray);
    sort($dirArray);
    print("<TABLE border=1 cellpadding=5 cellspacing=0 \n");
    print("<TR><TH>Filename</TH><TH>Filetype</th><th>Filesize</TH></TR>\n");
    for($index=0; $index < $indexCount; $index++) {
        if ((substr("$dirArray[$index]", 0, 1) != ".") 
                && (strrpos("$dirArray[$index]", ".stacktrace") != false)){ 
            print("<TR><TD>");
            print("<a href=\"$dirArray[$index]\">$dirArray[$index]</a>");
            print("</TD><TD>");
            print(filetype($dirArray[$index]));
            print("</TD><TD>");
            print(filesize($dirArray[$index]));
            print("</TD></TR>\n");
        }
    }
    print("</TABLE>\n");
?>

9
Penso che questo causerà problemi legali in alcuni stati / paesi
setzamora,

5
NOTA: HttpPost httpPost = new HttpPost(url);deve essere in un'attività asincrona (o gestore ... un thread separato) ora se stai prendendo di mira Honeycomb o versioni successive
Bryan Denny,

4
@Joset, che tipo di problemi legali e perché?
varevarao,

2
@varevarao Problemi legali (forse) perché stai inviando informazioni sensibili sul dispositivo senza il consenso dell'utente utilizzando la funzione Invia al server di questo codice.
caw

2
DefaultExceptionHandler sembra persistere in tutte le attività ricreative. Ho aggiornato la risposta per impostare il valore predefinito solo se un gestore personalizzato non è già impostato. Senza di essa, ciascun gestore detiene e chiama il precedente, fino a quello originale. Ciò causa problemi con la registrazione duplicata e problemi di perdita di memoria.
Dave McClelland,

57

Puoi anche provare [BugSense] Motivo: reindirizzamento spam a un altro URL . BugSense raccoglie e analizza tutti i rapporti sugli arresti anomali e fornisce rapporti visivi e significativi. È gratuito ed è solo 1 riga di codice per l'integrazione.

Disclaimer: sono un co-fondatore


4
Ho provato BugSense ed è fantastico. Interfaccia utente semplice e fresca, anche molto veloce. Nessuna caratteristica stupida gonfia. Facile vedere gli arresti più frequenti e anche scavare nello stacktrace.
vidstige

Ultimamente facciamo molto di più della semplice segnalazione di crash, ma questo non è il posto giusto per parlare di nuove funzionalità, ecc.
PanosJee,

Provato. Gli errori hanno funzionato anche se stacktrace non è troppo completo, i dati sugli arresti anomali in tempo reale non sono stati rilevati. La modalità debug non ha funzionato. Ho seguito il percorso di inizializzazione una volta dalla classe Application (che è ciò che ha senso per la maggior parte dei casi). BugSense ha una dashboard incredibile, un peccato che per qualche motivo i rapporti sugli arresti anomali non funzionano e la simbolizzazione non è nel livello gratuito. Mi ci sono voluti 5 minuti per installare GetSentry e ha funzionato per Android con questo client generico: github.com/joshdholtz/Sentry-Android
albertpeiro

3
BugSense è semplice e facile da integrare. MA È TROPPO COSTOSO. Possiamo ottenere le stesse funzionalità di rilevamento dei bug utilizzando Flurry analytics e Parse. Entrambi sono gratuiti e facili da integrare.
Venkat,

44

In Android 2.2 è ora possibile ottenere automaticamente rapporti sugli arresti anomali dalle applicazioni di Android Market:

La nuova funzionalità di segnalazione dei bug per le app di Android Market consente agli sviluppatori di ricevere report sugli arresti anomali e sui blocchi degli utenti. I rapporti saranno disponibili quando accedono al proprio account editore.

http://developer.android.com/sdk/android-2.2-highlights.html


Penso che non sia solo 2.2, ma semplicemente una nuova funzionalità di mercato offerta da Google. Alcuni giorni fa ho ricevuto una segnalazione di arresto anomalo e non ci dovrebbe essere un dispositivo froyo là fuori che utilizza la mia app.
Janusz,

1
@Janusz Sei sicuro? ci sono già versioni di Froyo per Nexus One, senza contare i Googler che gestiscono Froyo da un po '.
pupeno,

Almeno ci deve essere stato un aggiornamento nella versione sul telefono, anche solo un'altra revisione, ma come dovrebbe funzionare diversamente?
RoflcoptrException,

Non so se i rapporti siano stati inviati a Google prima. Il rapporto è alquanto strano perché google mostra un'interfaccia utente per l'invio dei loro video e questo deve essere un cambiamento nel sistema operativo e non solo nel mercato. Ma dice: Platforms 1 riporta rapporti / settimana e il droide non dovrebbe essere in froyo.
Janusz,

1
Il codice del pulsante "Segnala" è stato nell'AOSP per un po ', e Romain Guy (vagamente) ha risposto a una domanda al riguardo qui un paio di mesi fa.
Christopher Orr,

30

È possibile gestire queste eccezioni con Thread.setDefaultUncaughtExceptionHandler(), tuttavia questo sembra incasinare il metodo di gestione delle eccezioni di Android. Ho tentato di utilizzare un gestore di questa natura:

private class ExceptionHandler implements Thread.UncaughtExceptionHandler {
    @Override
    public void uncaughtException(Thread thread, Throwable ex){
        Log.e(Constants.TAG, "uncaught_exception_handler: uncaught exception in thread " + thread.getName(), ex);

        //hack to rethrow unchecked exceptions
        if(ex instanceof RuntimeException)
            throw (RuntimeException)ex;
        if(ex instanceof Error)
            throw (Error)ex;

        //this should really never happen
        Log.e(Constants.TAG, "uncaught_exception handler: unable to rethrow checked exception");
    }
}

Tuttavia, anche con il riproporre le eccezioni, non sono stato in grado di ottenere il comportamento desiderato, ovvero la registrazione dell'eccezione pur consentendo ad Android di arrestare il componente in cui era accaduto, quindi ho rinunciato dopo un po '.


Perché stai solo rilanciando eccezioni non controllate? Mi sembra che dovresti respingere tutte le eccezioni.
MatrixFrog,

Sembra che qualcuno abbia avuto successo con il tuo approccio: jyro.blogspot.com/2009/09/crash-report-for-android-app.html
MatrixFrog

1
Il trucco è ottenere il precedente UncaughtExceptionHandler predefinito e gestire l'eccezione a quell'oggetto dopo aver terminato di segnalare l'eccezione.
Tom,

Fa Constants.TAGparte del framework Android? La prima volta che lo vedo. Non riesco a trovarlo.
Haroun Hajem,

1
@HarounHajem Dobbiamo definire il nostro.
KYHSGeekCode

22

Vedo che la domanda è troppo vecchia e spero che la mia risposta sia utile per gli altri che hanno lo stesso problema ...

Dare Crashlytics una prova. Fornirà approfondimenti approfonditi su tutti gli arresti anomali su tutti i dispositivi che hanno la tua applicazione e ti invierà una notifica tramite e-mail .. E la parte migliore è che è completamente gratuita da usare ..


21

Ok, ho guardato i campioni forniti da rrainn e Soonil e ho trovato una soluzione che non rovina la gestione degli errori.

Ho modificato CustomExceptionHandler in modo che memorizzi UncaughtExceptionHandler originale dal thread che associamo a quello nuovo. Alla fine del nuovo "uncaughtException" - Metodo Ho appena chiamato la vecchia funzione utilizzando l'archiviazione UncaughtExceptionHandler.

Nella classe DefaultExceptionHandler è necessario sth. come questo:

public class DefaultExceptionHandler implements UncaughtExceptionHandler{
  private UncaughtExceptionHandler mDefaultExceptionHandler;

  //constructor
  public DefaultExceptionHandler(UncaughtExceptionHandler pDefaultExceptionHandler)
  {
       mDefaultExceptionHandler= pDefaultExceptionHandler;
  }
  public void uncaughtException(Thread t, Throwable e) {       
        //do some action like writing to file or upload somewhere         

        //call original handler  
        mStandardEH.uncaughtException(t, e);        

        // cleanup, don't know if really required
        t.getThreadGroup().destroy();
  }
}

Con quella modifica sul codice su http://code.google.com/p/android-remote-stacktrace hai una buona base di lavoro per accedere al tuo server web o alla scheda SD.


19

Google Play Developers Console ti fornisce effettivamente le tracce dello stack da quelle app che si sono bloccate e avevano inviato i rapporti, ha anche ottimi grafici per aiutarti a vedere le informazioni, vedi esempio di seguito:

inserisci qui la descrizione dell'immagine


2
In che modo gli utenti possono inviare i rapporti o come funziona esattamente se la tua app non si trova nel Play Store, puoi farlo a scopo di test?
Lion789,

Sai che esiste un progetto Android open source che pubblica i loro rapporti sugli arresti anomali?
Justin Civi,

1
Tieni presente che questo mostrerà solo gli arresti anomali, ANR che gli utenti hanno scelto di segnalare
sojin

Sì, comunque, quando hai una grande base di utenti hai molte possibilità che vengano segnalati tutti gli arresti anomali, e anche gli arresti anomali e gli ANR segnalati qui saranno i più importanti, perché le persone li segnaleranno più volte, in questo modo puoi filtrali e correggili in quella priorità (più report = bug più importante) mentre (nessun report = non quel bug critico).
Eefret il

18

Sto usando Crittercism per le mie app per Android e iOS - ne ho sentito parlare su Techcrunch. Abbastanza felice con loro finora!


Cordiali saluti: i rapporti sugli arresti anomali dal lato NDK non fanno parte del piano di base e rientrano nella "Segnalazione di incidenti estesa". Vedi: crittercism.com/pricing
ahash

1
Ho appena testato la segnalazione NDK su Fabric.io Crashlytics di Twitter ... abbastanza grande (il primo giorno di utilizzo), quando ho rilasciato per aggiungere la mappatura nel loro sistema è stato necessario un ulteriore passaggio, in modo che le tracce dello stack abbiano un bell'aspetto, ma ha risolto il problema l'errore NDK che ho usato per testare (ha fatto una chiamata "abort ();" in modo strategico in tutto il c ++ e ha fornito una traccia dello stack per i test.
Hunter-Orionnoir


11

usa questo per catturare i dettagli dell'eccezione:

String stackTrace = Log.getStackTraceString(exception); 

archiviarlo nel database e conservare il registro.


Come accedervi, mi darete qualche esempio. per favore se puoi. grazie in anticipo
Rajendra Verma,

8

Puoi anche usare un intero (semplice) servizio per esso piuttosto che solo una libreria. La nostra azienda ha appena rilasciato un servizio proprio per questo: http://apphance.com .

Ha una semplice libreria .jar (per Android) che aggiungi e integra in 5 minuti e quindi la libreria raccoglie non solo informazioni sugli arresti anomali ma anche registri dall'applicazione in esecuzione, oltre a consentire ai tester di segnalare i problemi direttamente dal dispositivo, incluso il tutto il contesto (rotazione del dispositivo, indipendentemente dal fatto che sia collegato a un wifi o altro). Puoi guardare i registri usando un pannello web molto utile e utile, dove puoi tenere traccia delle sessioni con la tua applicazione, arresti anomali, registri, statistiche e altro ancora. Il servizio è ora in fase di beta test chiuso, ma puoi richiedere l'accesso e te lo diamo molto rapidamente.

Disclaimer: sono CTO di Polidea e co-creatore del servizio.


7

Grazie risorse presenti per Stackoverflowaiutarmi a trovare questa risposta.

Puoi trovare i rapporti sugli arresti anomali di Android da remoto direttamente nella tua e-mail . ricorda che devi inserire la tua email nella classe CustomExceptionHandler .

public static String sendErrorLogsTo = "tushar.pandey@virtualxcellence.com" ;

Passaggi richiesti:

1) in onCreate della tua attività usa questa sezione del tuo codice.

    if(!(Thread.getDefaultUncaughtExceptionHandler() instanceof CustomExceptionHandler)) {
        Thread.setDefaultUncaughtExceptionHandler(new CustomExceptionHandler(this));
    }   

Secondo) utilizzare questa versione sovrascritta della classe CustomExceptionHandler di (rrainn), secondo il mio phpcript.

package com.vxmobilecomm.activity;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.io.Writer;
import java.lang.Thread.UncaughtExceptionHandler;
import java.util.ArrayList;
import java.util.List;

import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.HttpClient;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.BufferedHttpEntity;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.message.BasicNameValuePair;

import android.app.Activity;
import android.content.Context;
import android.content.pm.ApplicationInfo;
import android.content.pm.PackageManager;
import android.content.pm.PackageManager.NameNotFoundException;
import android.os.AsyncTask;
import android.util.Log;

public class CustomExceptionHandler implements UncaughtExceptionHandler {

    private UncaughtExceptionHandler defaultUEH;
    public static String sendErrorLogsTo = "tushar.pandey@virtualxcellence.com" ;

    Activity activity;

    public CustomExceptionHandler(Activity activity) {
        this.defaultUEH = Thread.getDefaultUncaughtExceptionHandler();
        this.activity = activity;
    }

    public void uncaughtException(Thread t, Throwable e) {

        final Writer result = new StringWriter();
        final PrintWriter printWriter = new PrintWriter(result);
        e.printStackTrace(printWriter);
        String stacktrace = result.toString();
        printWriter.close();
        String filename = "error" + System.nanoTime() + ".stacktrace";

        Log.e("Hi", "url != null");
        sendToServer(stacktrace, filename);

        StackTraceElement[] arr = e.getStackTrace();
        String report = e.toString() + "\n\n";
        report += "--------- Stack trace ---------\n\n";
        for (int i = 0; i < arr.length; i++) {
            report += "    " + arr[i].toString() + "\n";
        }
        report += "-------------------------------\n\n";

        report += "--------- Cause ---------\n\n";
        Throwable cause = e.getCause();
        if (cause != null) {
            report += cause.toString() + "\n\n";
            arr = cause.getStackTrace();
            for (int i = 0; i < arr.length; i++) {
                report += "    " + arr[i].toString() + "\n";
            }
        }
        report += "-------------------------------\n\n";

        defaultUEH.uncaughtException(t, e);
    }

    private void sendToServer(String stacktrace, String filename) {
        AsyncTaskClass async = new AsyncTaskClass(stacktrace, filename,
                getAppLable(activity));
        async.execute("");
    }

    public String getAppLable(Context pContext) {
        PackageManager lPackageManager = pContext.getPackageManager();
        ApplicationInfo lApplicationInfo = null;
        try {
            lApplicationInfo = lPackageManager.getApplicationInfo(
                    pContext.getApplicationInfo().packageName, 0);
        } catch (final NameNotFoundException e) {
        }
        return (String) (lApplicationInfo != null ? lPackageManager
                .getApplicationLabel(lApplicationInfo) : "Unknown");
    }

    public class AsyncTaskClass extends AsyncTask<String, String, InputStream> {
        InputStream is = null;
        String stacktrace;
        final String filename;
        String applicationName;

        AsyncTaskClass(final String stacktrace, final String filename,
                String applicationName) {
            this.applicationName = applicationName;
            this.stacktrace = stacktrace;
            this.filename = filename;
        }

        @Override
        protected InputStream doInBackground(String... params) 
        { 
            HttpClient httpclient = new DefaultHttpClient();
            HttpPost httppost = new HttpPost(
                    "http://suo-yang.com/books/sendErrorLog/sendErrorLogs.php?");

            Log.i("Error", stacktrace);

            try {
                List<NameValuePair> nameValuePairs = new ArrayList<NameValuePair>(
                        6);

                nameValuePairs.add(new BasicNameValuePair("data", stacktrace));
                nameValuePairs.add(new BasicNameValuePair("to",sendErrorLogsTo));
                nameValuePairs.add(new BasicNameValuePair("subject",applicationName));

                httppost.setEntity(new UrlEncodedFormEntity(nameValuePairs));

                HttpResponse response = httpclient.execute(httppost);

                HttpEntity entity1 = response.getEntity();

                BufferedHttpEntity bufHttpEntity = new BufferedHttpEntity(
                        entity1);

                is = bufHttpEntity.getContent();

            } catch (ClientProtocolException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }

            return is;
        }

        @Override
        protected void onPostExecute(InputStream result) {
            super.onPostExecute(result);

            Log.e("Stream Data", getStringFromInputStream(is));
        }
    }

    // convert InputStream to String
    private static String getStringFromInputStream(InputStream is) {

        BufferedReader br = null;
        StringBuilder sb = new StringBuilder();

        String line;
        try {

            br = new BufferedReader(new InputStreamReader(is));
            while ((line = br.readLine()) != null) {
                sb.append(line);
            }

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (br != null) {
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

        return sb.toString();

    }
}

6

Ora un giorno i rapporti di crash di Firebase sono molto popolari e più facili da usare. Per ulteriori informazioni, consultare il seguente collegamento: Firebase Crash Reporting

Spero che ti possa aiutare.


5

Questo è molto bruto, ma è possibile eseguire logcat ovunque, quindi un trucco rapido e sporco è da aggiungere a qualsiasi blocco di cattura getRuntime().exec("logcat >> /sdcard/logcat.log");


Ciò darebbe l'output del registro di tutte le app. Il filtro per app tagname potrebbe essere corretto, ma non pensare che questo sarebbe un buon modo di procedere poiché le voci potrebbero essere cumulative. La cancellazione dell'output di logcat dopo ogni scrittura potrebbe risolvere il problema.
bschandramohan,

5

C'è uno strumento chiamato fabric, questo è uno strumento di analisi degli arresti anomali, che ti permetterà di ottenere rapporti sugli arresti anomali, quando l'applicazione viene distribuita dal vivo e durante lo sviluppo. L'aggiunta di questo strumento all'applicazione è stata altrettanto semplice. Quando il crash dell'applicazione è possibile visualizzare quel report del crash dalla dashboard di fabric.io. il rapporto è stato catturato automaticamente. non chiederà l'autorizzazione all'utente. Se desidera inviare il rapporto bug / crash. E questo è completamente gratuito ... https://get.fabric.io/


5

Google Firebase è l'ultimo modo di Google (2016) di fornirti i dati di arresto anomalo / errore sul telefono. Includilo nel tuo file build.gradle:

compile 'com.google.firebase:firebase-crash:9.0.0'

Gli arresti anomali irreversibili vengono registrati automaticamente senza richiedere l'input dell'utente e puoi anche registrare arresti anomali non fatali o altri eventi in questo modo:

try
{

}
catch(Exception ex)
{
    FirebaseCrash.report(new Exception(ex.toString()));
}

5

C'è questa libreria Android chiamata Sherlock . Ti dà il rapporto completo di crash insieme alle informazioni sul dispositivo e sull'applicazione. Ogni volta che si verifica un arresto anomalo, viene visualizzata una notifica nella barra delle notifiche e facendo clic sulla notifica si aprono i dettagli dell'arresto anomalo. Puoi anche condividere i dettagli dell'arresto anomalo con altri utenti tramite e-mail o altre opzioni di condivisione.

Installazione

android {
    dataBinding {
      enabled = true
    }
}

compile('com.github.ajitsing:sherlock:1.0.0@aar') {
    transitive = true
}

dimostrazione

inserisci qui la descrizione dell'immagine


5

Mentre molte delle risposte in questa pagina sono utili, è facile per loro diventare obsolete. Il sito Web di AppBrain aggrega statistiche che consentono di trovare la soluzione di segnalazione di crash più popolare attualmente disponibile:

Librerie di segnalazione di crash di Android

sito Web del cervello dell'app

Puoi vedere che al momento della pubblicazione di questa immagine, Crashlytics viene utilizzato nel 5,24% delle app e nel 12,38% delle installazioni.


4

Usiamo il nostro sistema di coltivazione domestica all'interno dell'azienda e ci serve molto bene. È una libreria Android che invia report sugli arresti anomali al server e al server che riceve report e crea analisi. Il server raggruppa le eccezioni per nome eccezione, stacktrace, messaggio. Aiuta a identificare i problemi più critici che devono essere risolti. Il nostro servizio è ora in beta pubblica, quindi tutti possono provarlo. Puoi creare un account su http://watchcat.co oppure puoi dare un'occhiata a come funziona usando l'accesso demo http://watchcat.co/reports/index.php?demo .


3

Se vuoi risposte immediate puoi usare logcat

$adb shell logcat -f /sdcard/logoutput.txt *:E

Se c'è troppa spazzatura nel tuo registro in questo momento, prova prima a cancellarlo.

$adb shell logcat -c

Quindi prova a eseguire l'app, quindi accedi nuovamente a logcat.


Non è comunque necessario collegare il dispositivo a un PC (ad es. Con un cavo)?
Gerard,

3

Ho trovato un'altra fantastica applicazione web per tenere traccia dei rapporti di errore.

https://mint.splunk.com/

Piccolo numero di passaggi da configurare.

  1. Accedi o registrati e configura usando il link sopra. Una volta terminata la creazione di un'applicazione, forniranno una linea da configurare come di seguito.
Mint.initAndStartSession(YourActivity.this, "api_key");
  1. Aggiungi quanto segue nel build.gradl dell'applicazione.
android {
...
    repositories {
        maven { url "https://mint.splunk.com/gradle/"}
    }
...
}

dependencies {
...
    compile "com.splunk.mint:mint:4.4.0"
...
}
  1. Aggiungi il codice che abbiamo copiato sopra e aggiungilo a ogni attività.

    Mint.initAndStartSession (YourActivity.this, "api_key");

Questo è tutto. Effettuando il login e vai nella dashboard dell'applicazione, otterrai tutti i rapporti sugli errori.

Spero che aiuti qualcuno.


Quanto costa questo?
user2966445

2

Per un servizio alternativo di monitoraggio degli arresti anomali / monitoraggio delle eccezioni, consulta Raygun.io : ha una buona logica per la gestione degli arresti anomali Android, inclusa un'esperienza utente decente quando la colleghi alla tua app (due righe di codice nella tua attività principale e alcune linee di XML incollate in AndroidManifest).

Quando l'app si arresta in modo anomalo, acquisisce automaticamente la traccia dello stack, i dati sull'ambiente per hard / software, informazioni di tracciamento dell'utente, eventuali dati personalizzati specificati ecc. La pubblica in modo asincrono nell'API, quindi nessun blocco del thread dell'interfaccia utente e la memorizza nella cache su disco se non è disponibile alcuna rete.

Disclaimer: ho creato il provider Android :)


1

Ho appena iniziato a utilizzare ACRA https://github.com/ACRA/acra utilizzando Google Forms come backend ed è molto facile da configurare e utilizzare, è l'impostazione predefinita.

MA l'invio di rapporti a Google Forms sarà deprecato (quindi rimosso): https://plus.google.com/118444843928759726538/posts/GTTgsrEQdN6 https://github.com/ACRA/acra/wiki/Notice-on-Google -Form foglio di calcolo-uso

È comunque possibile definire il proprio mittente https://github.com/ACRA/acra/wiki/AdvancedUsage#wiki-Implementing_your_own_sender è possibile provare ad esempio il mittente dell'e-mail.

Con il minimo sforzo è possibile inviare segnalazioni a bugsense: http://www.bugsense.com/docs/android#acra

NB L'account bugsense è limitato a 500 report / mese


1

In ritardo per la festa, sostengo e credo che ACRA sia l'opzione migliore tra tutte. È facile da installare e configurare. Ho creato una guida dettagliata con input da ogni parte per recuperare il rapporto sugli arresti anomali usando ACRA e spedire lo stesso al mio indirizzo e-mail usando MandrillAp.

Link al post: https://androidician.wordpress.com/2015/03/29/sending-crash-reports-with-acra-over-email-using-mandrill/

Link al progetto di esempio su github: https://github.com/ayushhgoyal/AcraSample


1

Sono uno dei fondatori di Bugsnag che abbiamo progettato proprio per questo scopo. Bugsnag acquisisce automaticamente le eccezioni non gestite nelle app Android e le invia alla nostra dashboard, dove puoi dare la priorità alle correzioni e immergerti nelle informazioni diagnostiche.

Ecco alcune cose importanti da considerare quando si seleziona o si crea un sistema di segnalazione degli arresti anomali, insieme ad alcuni frammenti di codice:

  • Rileva automaticamente le eccezioni non gestite ( esempio di codice )
  • Raccoglie dati diagnostici come utilizzo della memoria, informazioni sul dispositivo, ecc. ( Esempio di codice )
  • Raggruppa efficacemente gli arresti anomali per causa principale
  • Consente di tenere traccia delle azioni eseguite dall'utente prima di ogni arresto anomalo per consentire la riproduzione ( esempio di codice )

Se vuoi vedere alcune best practice sulla gestione / segnalazione degli arresti anomali su Android puoi consultare il codice sorgente completo per la libreria di report sugli arresti anomali di Bugsnag, che è completamente open source, sentiti libero di separarlo e utilizzarlo nelle tue applicazioni!


0

Se la tua app viene scaricata da altre persone e si arresta in modo anomalo su dispositivi remoti, potresti voler esaminare una libreria di segnalazione errori Android (indicata in questo post SO ). Se è solo sul tuo dispositivo locale, puoi usare LogCat. Anche se il dispositivo non è stato collegato a un computer host quando si è verificato l'arresto anomalo, il dispositivo collegato e l'emissione di un comando adb logcat scaricherà l'intera cronologia logcat (almeno nella misura in cui è bufferizzata, che di solito è un carico di dati di registro , non è semplicemente infinito). Una di queste opzioni risponde alla tua domanda? Altrimenti puoi tentare di chiarire un po 'di più quello che stai cercando?



0

Google ha modificato la quantità di segnalazioni sugli arresti anomali che effettivamente ricevi. In precedenza hai ricevuto solo segnalazioni di bug segnalate manualmente.

Dall'ultima conferenza degli sviluppatori e dall'introduzione di Android Vitals ricevi anche rapporti sugli arresti anomali da parte degli utenti che hanno abilitato la condivisione dei dati di diagnostica.

Vedrai tutti gli arresti anomali raccolti dai dispositivi Android i cui utenti hanno scelto di condividere automaticamente i dati di utilizzo e di diagnostica. I dati sono disponibili per i due mesi precedenti.

Visualizza gli arresti anomali e gli errori dell'applicazione che non rispondono (ANR)


logcat sta dicendo che c'è un file di dump dell'arresto anomalo dell'output in /data/user/0/com.<myappname>/cache/WebView/Crash Report / <GUUID> .dmp, ma il dispositivo non è rootato e non riesco a capire come accedere a questo file!
Michael,

0

Puoi farlo direttamente in Android Studio. Basta connettere il telefono, eseguire l'app, lasciarlo in crash e puoi visualizzare lo stacktrace direttamente in Android Studio.

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.