library - print to logcat android




Come ottengo i dati di crash dalla mia applicazione Android? (20)

È possibile gestire queste eccezioni con Thread.setDefaultUncaughtExceptionHandler() , tuttavia questo sembra Thread.setDefaultUncaughtExceptionHandler() in cui Android gestisce le eccezioni. 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 ripensamento delle eccezioni, non sono stato in grado di ottenere il comportamento desiderato, ad esempio registrando l'eccezione pur consentendo ad Android di arrestare il componente in cui si era verificato, quindi ho rinunciato a farlo dopo un po '.

Come posso ottenere dati di crash (tracce dello stack almeno) dalla mia applicazione Android? Almeno quando si lavora sul mio dispositivo che viene recuperato via cavo, ma idealmente da qualsiasi istanza della mia applicazione in esecuzione in the wild in modo che io possa migliorarlo e renderlo più solido.


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-Spreadsheet-usage

In ogni caso è possibile definire il proprio mittente https://github.com/ACRA/acra/wiki/AdvancedUsage#wiki-Implementing_your_own_sender si può provare ad inviare il mittente.

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

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


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. Anche l'aggiunta di questo strumento alla tua applicazione era semplice. Quando l'applicazione si arresta, il rapporto del crash può essere visualizzato dal dashboard fabric.io. il rapporto è stato rilevato automaticamente. Non chiederà l'autorizzazione all'utente. Se lui / lei vuole inviare il bug / rapporto di crash. E questo è completamente gratuito ... https://get.fabric.io/


Google Play Developers Console ti fornisce effettivamente le tracce dello stack da quelle app che si sono arrestate in modo anomalo e ha inviato i rapporti, ma ha anche un ottimo grafico per aiutarti a visualizzare le informazioni, vedi esempio di seguito:


Grazie alle risorse presenti in per aiutarmi a trovare questa risposta.

Puoi trovare i tuoi rapporti di arresto anomalo di Android direttamente nella tua email . ricorda che devi mettere la tua email all'interno della classe CustomExceptionHandler .

public static String sendErrorLogsTo = "[email protected]" ;

Passi richiesti:

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

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

2) usa questa versione sovrascritta della classe CustomExceptionHandler di (rrainn), secondo il mio phpScript.

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 = "[email protected]" ;

    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();

    }
}

Ho creato la mia versione qui: http://androidblogger.blogspot.com/2009/12/how-to-improve-your-application-crash.html

È fondamentalmente la stessa cosa, ma sto utilizzando una mail piuttosto che una connessione http per inviare il report e, cosa più importante, ho aggiunto alcune informazioni come la versione dell'applicazione, la versione del sistema operativo, il modello del telefono o la memoria disponibile al mio rapporto. .


Ho usato Crittercism per le mie app per Android e iOS: ne ho sentito parlare su techcrunch. Abbastanza felice con loro finora!


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

La nuova funzionalità di segnalazione dei bug per le app di Android Market consente agli sviluppatori di ricevere arresti anomali e blocchi dei report dai propri utenti. I rapporti saranno disponibili quando accedono al loro account publisher.

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


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

Librerie di segnalazione degli arresti anomali di Android

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


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

Ho modificato CustomExceptionHandler in modo che memorizzi l'originale UncaughtExceptionHandler dal Thread che associamo a quello nuovo. Alla fine della nuova "uncaughtException" - Metodo, chiamo semplicemente la vecchia funzione usando la memorizzata UncaughtExceptionHandler.

Nella classe DefaultExceptionHandler hai bisogno di 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 questa modifica sul codice all'indirizzo http://code.google.com/p/android-remote-stacktrace hai una buona base di lavoro per l'accesso al campo al tuo web server o alla sd-card.


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

Quando la tua app si arresta, acquisisce automaticamente la traccia dello stack, i dati ambientali per hard / software, informazioni sul tracciamento degli utenti, eventuali dati personalizzati specificati, ecc. Lo invia all'API in modo asincrono, quindi non blocca il thread dell'interfaccia utente e lo memorizza nella cache su disco se non c'è rete disponibile.

Disclaimer: ho creato il provider Android :)


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

ACRA è una libreria che consente all'applicazione Android di pubblicare automaticamente i propri rapporti sugli arresti anomali su un modulo di GoogleDoc. È destinato 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 server ovunque ... i report vengono inviati a un foglio di calcolo di Google Docs!


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

Ha una semplice libreria .jar (per Android) che si aggiunge e si integra in 5 minuti e quindi la libreria raccoglie non solo le informazioni sugli arresti anomali ma anche i registri dall'applicazione in esecuzione, oltre a consentire ai tester di segnalare problemi direttamente dal dispositivo, incluso il intero contesto (rotazione del dispositivo, se è collegato a un wifi o meno e altro). Puoi guardare i registri utilizzando un pannello Web molto utile e utile, in cui puoi tenere traccia delle sessioni con la tua applicazione, arresti anomali, registri, statistiche e altro. Il servizio è in fase di beta test chiusa, ma puoi richiedere l'accesso e te lo consegneremo molto rapidamente.

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


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


Se la tua app viene scaricata da altre persone e si blocca su dispositivi remoti, potresti voler esaminare una libreria di segnalazione degli errori Android (a cui si fa riferimento in questo post SO ). Se è solo sul proprio dispositivo locale, è possibile utilizzare LogCat. Anche se il dispositivo non è stato collegato a una macchina host quando si è verificato l'arresto anomalo, il dispositivo connesso e l'emissione di un comando adb logcat scaricheranno l'intera cronologia logcat (almeno nella misura in cui è memorizzata nel buffer, che di solito è un loooot di dati di registro , non è infinito). Una di queste opzioni risponde alla tua domanda? Se no, puoi tentare di chiarire che cosa stai cercando un po 'di più?


Se vuoi le risposte immediatamente, puoi usare logcat

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

Se nel registro ci sono troppe cianfrusaglie, prova prima a svuotare.

$adb shell logcat -c

Quindi prova a eseguire l'app e poi di nuovo il logcat.


Usiamo il nostro sistema interno all'interno dell'azienda e ci serve molto bene. È una libreria di Android che invia rapporti di arresti anomali a server e server che ricevono report e fanno alcune analisi. Il server raggruppa le eccezioni per nome dell'eccezione, stacktrace, messaggio. Aiuta ad identificare la maggior parte dei problemi critici che devono essere risolti. Il nostro servizio è in beta pubblica ora così tutti possono provarlo. Puoi creare un account su http://watchcat.co o puoi semplicemente dare un'occhiata a come funziona usando l'accesso demo http://watchcat.co/reports/index.php?demo .


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

Dai una prova a Crashlytics . Fornirà informazioni approfondite su tutti gli arresti anomali su tutti i dispositivi che hanno la tua applicazione e ti invierà una notifica tramite e-mail. La parte migliore è completamente gratuita.



Google Firebase è il modo più recente di Google (2016) per fornire dati sugli arresti anomali / errori sul telefono. Includilo nel tuo file build.gradle:

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

Arresti anomali irreversibili vengono registrati automaticamente senza richiedere l'intervento dell'utente e puoi anche registrare i crash non fatali o altri eventi in questo modo:

try
{

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




stack-trace