Comment obtenir des données de plantage depuis mon application Android?


737

Comment puis-je obtenir des données de plantage (traces de pile au moins) à partir de mon application Android? Au moins lorsque je travaille sur mon propre appareil récupéré par câble, mais idéalement à partir de n'importe quelle instance de mon application s'exécutant à l'état sauvage afin que je puisse l'améliorer et la rendre plus solide.



Je vois que cela envoie le rapport à un serveur distant. Peut-il également enregistrer l'exception dans un fichier local?

1
Rapport de plantage d'
gdonald

Celui-ci semble être le plus robuste, qu'en est-il si le rapport ne parvient pas à télécharger après toutes les tentatives, peut-il alors enregistrer le fichier ou sqlite db?
JPM

Réponses:


354

Vous pouvez essayer la bibliothèque ACRA (Application Crash Report pour Android) :

ACRA est une bibliothèque permettant à l'application Android de publier automatiquement ses rapports de plantage sur un formulaire GoogleDoc. Il est destiné aux développeurs d'applications Android pour les aider à obtenir des données de leurs applications en cas de panne ou de comportement erroné.

Il est facile à installer dans votre application, hautement configurable et ne nécessite pas d'héberger un script de serveur n'importe où ... les rapports sont envoyés vers une feuille de calcul Google Doc!


8
Ceci est facile à configurer et à utiliser. Recommandé pour une utilisation avant la mise sur le marché, et même éventuellement après.
mxcl

1
J'ai commencé à l'utiliser et c'est incommensurablement mieux que le rapport d'erreurs dans Flurry que j'avais auparavant ou celui fait maison avec lequel j'ai commencé. Jusqu'à présent, je suis content de "acra".
Adrian Spinei

8
Le gros avantage d'Acra est la possibilité d'utiliser les API Google pour analyser et visualiser facilement les données, voir jberkel.github.com/sms-backup-plus/acra-analysis pour un exemple sur la façon de procéder.
Jan Berkel

3
Semble très instable pour moi. L'ACRA lui-même s'est écrasé et a envoyé un rapport de plantage sur lui-même et non le plantage de l'application associée. -1
Sandor

19
Google Docs en tant que backend n'est plus pris en charge
eliocs

305

Pour des exemples d'applications et à des fins de débogage, j'utilise une solution simple qui me permet d'écrire le stacktrace sur la carte SD de l'appareil et / ou de le télécharger sur un serveur. Cette solution a été inspirée par le projet android-remote-stacktrace (en particulier, les parties d'enregistrement sur l'appareil et de téléchargement sur le serveur) et je pense qu'elle résout le problème mentionné par Soonil. Ce n'est pas optimal, mais cela fonctionne et vous pouvez l'améliorer si vous souhaitez l'utiliser dans une application de production. Si vous décidez de télécharger les traces de pile sur le serveur, vous pouvez utiliser un script php ( index.php) pour les afficher. Si vous êtes intéressé, vous pouvez trouver toutes les sources ci-dessous - une classe java pour votre application et deux scripts php facultatifs pour le serveur hébergeant les stacktraces téléchargées.

Dans un contexte (par exemple, l'activité principale), appelez

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
Je pense que cela entraînera des problèmes juridiques dans certains États / pays
setzamora

5
REMARQUE: HttpPost httpPost = new HttpPost(url);doit être dans une tâche asynchrone (ou gestionnaire ... un thread séparé) maintenant si vous ciblez Honeycomb ou plus tard
Bryan Denny

4
@Joset, quel genre de problèmes juridiques et pourquoi?
varevarao

2
@varevarao Problèmes juridiques (peut-être) car vous envoyez des informations sensibles sur l'appareil sans le consentement de l'utilisateur en utilisant la fonction d'envoi au serveur de ce code.
caw

2
Le defaultExceptionHandler semble persister à travers la récréation d'activité. J'ai mis à jour la réponse pour ne définir la valeur par défaut que si un gestionnaire personnalisé n'est pas déjà défini. Sans cela, chaque gestionnaire détient et appelle le précédent, jusqu'à l'original. Cela provoque des problèmes de journalisation en double ainsi que des problèmes de fuite de mémoire.
Dave McClelland

57

Vous pouvez également essayer [BugSense] Reason: Spam Redirect vers une autre URL . BugSense recueille et analyse tous les rapports d'erreur et vous fournit des rapports significatifs et visuels. C'est gratuit et c'est seulement 1 ligne de code pour s'intégrer.

Avertissement: je suis co-fondateur


4
J'ai essayé BugSense et son génial. Interface utilisateur simple et fraîche, très rapide aussi. Aucune bêtise de fonctionnalité stupide. Facile à voir les plantages les plus fréquents et aussi à creuser dans le stacktrace.
vidstige

Ces derniers temps, nous faisons bien plus que de simples rapports de crash, mais ce n'est pas le bon endroit pour parler de nouvelles fonctionnalités, etc.
PanosJee

Essayé. Les erreurs ont fonctionné bien que stacktrace ne soit pas trop complet, les données de plantage en temps réel n'ont pas été transmises. Le mode de débogage n'a pas fonctionné. J'ai cependant emprunté la route initialize-once de la classe Application (ce qui est logique dans la plupart des cas). BugSense a un tableau de bord incroyable, une telle honte que pour une raison quelconque, les rapports de plantage ne fonctionnent pas et que la symbolisation ne soit pas dans le niveau gratuit. Il m'a fallu 5 minutes pour installer GetSentry et cela a fonctionné immédiatement pour Android avec ce client à usage général: github.com/joshdholtz/Sentry-Android
albertpeiro

3
BugSense est simple et facile à intégrer. MAIS C'EST TROP CHER. Nous pouvons obtenir les mêmes fonctionnalités de détection de bogues en utilisant les analyses Flurry et Parse. Les deux sont gratuits et faciles à intégrer.
venkat

44

Dans Android 2.2, il est désormais possible d'obtenir automatiquement les rapports de plantage des applications Android Market:

La nouvelle fonctionnalité de rapport de bogues pour les applications Android Market permet aux développeurs de recevoir des rapports de plantage et de gel de leurs utilisateurs. Les rapports seront disponibles lorsqu'ils se connecteront à leur compte d'éditeur.

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


Je pense que ce n'est pas seulement la version 2.2, mais simplement une nouvelle fonctionnalité du marché proposée par Google. J'ai reçu un rapport de plantage il y a quelques jours et il ne devrait pas y avoir d'appareil Froyo à l'aide de mon application.
Janusz

1
@Janusz Êtes-vous sûr? il existe déjà des versions de Froyo pour Nexus One, sans compter les Googleurs qui utilisent Froyo depuis un certain temps.
pupeno

Au moins, il doit y avoir une mise à jour dans la version sur le téléphone, même sa juste une autre révision, mais comment cela devrait-il fonctionner autrement?
RoflcoptrException

Je ne sais pas si les rapports ont été envoyés à Google auparavant. Le rapport est quelque peu étrange car google montre une interface utilisateur pour l'envoi de leurs vidéos et cela doit être un changement dans le système d'exploitation et pas seulement le marché. Mais cela dit: Platforms 1 rapporte des rapports / semaine et le droïde ne devrait pas être sur froyo.
Janusz

1
Le code du bouton "Signaler" est dans l'AOSP depuis un certain temps, et Romain Guy (vaguement) a répondu à une question à ce sujet ici il y a quelques mois.
Christopher Orr

30

Il est possible de gérer ces exceptions avec Thread.setDefaultUncaughtExceptionHandler(), mais cela semble gâcher la méthode Android de gestion des exceptions. J'ai tenté d'utiliser un gestionnaire de cette nature:

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");
    }
}

Cependant, même avec l'annulation des exceptions, je n'ai pas pu obtenir le comportement souhaité, c'est-à-dire la journalisation de l'exception tout en permettant à Android de fermer le composant.


Pourquoi relancez-vous uniquement des exceptions non contrôlées? Il me semble que vous devriez repousser toutes les exceptions.
MatrixFrog

On dirait que quelqu'un a réussi avec votre approche: jyro.blogspot.com/2009/09/crash-report-for-android-app.html
MatrixFrog

1
L'astuce consiste à obtenir l'ancien UncaughtExceptionHandler par défaut et à gérer l'exception à cet objet après avoir terminé de signaler l'exception.
Tom

Fait Constants.TAGpartie du framework Android? La première fois que je le vois. Je n'arrive pas à le trouver.
Haroun Hajem

1
@HarounHajem Nous devons définir les nôtres.
KYHSGeekCode

22

Je vois que la question est trop ancienne et j'espère que ma réponse sera utile pour d'autres ayant le même problème ...

Essayez Crashlytics . Il donnera un aperçu approfondi de tous les plantages sur tous les appareils ayant votre application et vous enverra une notification par e-mail. Et la meilleure partie est son utilisation entièrement gratuite.


21

Ok, eh bien j'ai regardé les échantillons fournis par rrainn et Soonil, et j'ai trouvé une solution qui ne gâche pas la gestion des erreurs.

J'ai modifié le CustomExceptionHandler afin qu'il stocke le UncaughtExceptionHandler d'origine à partir du thread que nous associons au nouveau. À la fin de la nouvelle "uncaughtException" - Méthode, j'appelle simplement l'ancienne fonction en utilisant le UncaughtExceptionHandler stocké.

Dans la classe DefaultExceptionHandler, vous avez besoin de qch. comme ça:

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

Avec cette modification sur le code http://code.google.com/p/android-remote-stacktrace, vous disposez d'une bonne base de travail pour vous connecter sur le terrain à votre serveur Web ou à la carte SD.


19

Google Play Developers Console vous donne en fait les traces de la pile des applications qui se sont écrasées et qui ont envoyé les rapports, il a également de très bons graphiques pour vous aider à voir les informations, voir l'exemple ci-dessous:

entrez la description de l'image ici


2
Comment les utilisateurs envoient-ils les rapports ou comment cela fonctionne-t-il exactement si votre application n'est pas dans le Play Store, pouvez-vous le faire à des fins de test?
Lion789

Savez-vous qu'il existe un projet Android open source qui publie leurs rapports de plantage?
Justin Civi

1
Veuillez noter que cela n'affichera que les plantages, ANR que les utilisateurs ont choisi de signaler
sojin

Oui, en effet, de toute façon, lorsque vous avez une grande base d'utilisateurs, vous avez beaucoup de possibilités de signaler tous les plantages, et les plantages et les ANR signalés ici seront les plus importants, car les gens les signaleront plus souvent, de cette façon vous pouvez filtrez et corrigez-les dans cette priorité (plus de rapports = bogue plus important) tandis que (aucun rapport = pas ce bogue critique).
Eefret

18

J'utilise Crittercism pour mes applications Android et iOS - j'en ai entendu parler sur techcrunch. Assez heureux avec eux jusqu'à présent!


Pour info: les rapports de plantage du côté NDK ne font pas partie du plan de base, et relèvent de "Extended Crash Reporting". Voir: crittercism.com/pricing
ahash

1
Je viens de tester le rapport NDK sur Fabric.io Crashlytics de Twitter ... plutôt bien (le premier jour d'utilisation), il a fallu une étape supplémentaire lorsque je relâche pour mettre le mappage dans leur système afin que les traces de pile semblent bonnes, mais cela a cloué l'erreur NDK que j'avais l'habitude de tester (fait un appel "abort ();" stratégiquement tout au long du c ++ et il a fourni une trace de pile pour les tests.
Hunter-Orionnoir


11

utilisez ceci pour attraper les détails de l'exception:

String stackTrace = Log.getStackTraceString(exception); 

stocker cela dans la base de données et maintenir le journal.


Comment accéder à cette base de données, me donnerez-vous un exemple. s'il vous plaît si vous le pouvez. merci dans advacne
Rajendra Verma

8

Vous pouvez également utiliser un service complet (simple) pour celui-ci plutôt qu'une seule bibliothèque. Notre société vient de publier un service juste pour cela: http://apphance.com .

Il possède une simple bibliothèque .jar (pour Android) que vous ajoutez et intégrez en 5 minutes, puis la bibliothèque rassemble non seulement des informations sur les plantages, mais également des journaux de l'application en cours d'exécution, et permet à vos testeurs de signaler les problèmes directement à partir de l'appareil - y compris le tout le contexte (rotation de l'appareil, qu'il soit connecté ou non à un wifi et plus). Vous pouvez consulter les journaux à l'aide d'un panneau Web très agréable et utile, où vous pouvez suivre les sessions avec votre application, les plantages, les journaux, les statistiques et plus encore. Le service est actuellement en phase de test bêta fermé, mais vous pouvez demander l'accès et nous vous le donnons très rapidement.

Avertissement: je suis CTO de Polidea et co-créateur du service.


7

Merci aux ressources présentes de Stackoverflowm'aider à trouver cette réponse.

Vous pouvez trouver vos rapports de plantage Android à distance directement dans votre e-mail . rappelez-vous que vous devez mettre votre e-mail dans la classe CustomExceptionHandler .

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

Étapes requises:

1er) dans la création de votre activité, utilisez cette section de votre code.

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

2e) utiliser cette version redéfinie de la classe CustomExceptionHandler de (rrainn), selon mon 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 = "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

Aujourd'hui, les rapports d'incidents Firebase sont très populaires et plus faciles à utiliser. Veuillez consulter le lien suivant pour plus d'informations: Firebase Crash Reporting

J'espère que cela vous aidera.


5

C'est très brut, mais il est possible d'exécuter logcat n'importe où, donc un hack rapide et sale est d'ajouter à n'importe quel bloc catch getRuntime().exec("logcat >> /sdcard/logcat.log");


Cela donnerait la sortie du journal de toutes les applications. Le filtrage par la variable App pourrait être correct, mais ne pense pas que ce serait une bonne façon de procéder, car les entrées pourraient être cumulatives. Cependant, la suppression de la sortie logcat après chaque écriture peut résoudre ce problème.
bschandramohan

5

Il existe un outil appelé fabric, c'est un outil d'analyse des plantages, qui vous permettra d'obtenir des rapports de plantages, lors du déploiement de l'application en direct et pendant le développement. L'ajout de cet outil à votre application a également été simple. Lorsque votre application se bloque, le rapport de l'accident peut être affiché à partir de votre tableau de bord fabric.io. Le rapport a été capturé automatiquement. Il ne demandera pas la permission à l'utilisateur. S'il souhaite envoyer le rapport de bug / crash. Et c'est totalement gratuit ... https://get.fabric.io/


5

Google Firebase est la dernière façon (2016) de Google de vous fournir des données de plantage / erreur sur votre téléphone. Incluez-le dans votre fichier build.gradle:

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

Les plantages fatals sont enregistrés automatiquement sans nécessiter la saisie de l'utilisateur et vous pouvez également consigner les plantages non fatals ou d'autres événements comme ceci:

try
{

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

5

Il y a cette bibliothèque Android appelée Sherlock . Il vous donne le rapport complet de l'accident ainsi que les informations sur l'appareil et l'application. Chaque fois qu'un crash se produit, il affiche une notification dans la barre de notification et en cliquant sur la notification, il ouvre les détails du crash. Vous pouvez également partager les détails du plantage avec d'autres par e-mail ou par d'autres options de partage.

Installation

android {
    dataBinding {
      enabled = true
    }
}

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

Démo

entrez la description de l'image ici


5

Bien que de nombreuses réponses sur cette page soient utiles, il est facile pour elles de devenir obsolètes. Le site Web AppBrain regroupe des statistiques qui vous permettent de trouver la solution de rapport d'incident la plus populaire qui soit actuelle:

Bibliothèques de rapports de plantage Android

site web du cerveau de l'application

Vous pouvez voir qu'au moment de publier cette image, Crashlytics est utilisé dans 5,24% des applications et 12,38% des installations.


4

Nous utilisons notre système local au sein de l'entreprise et il nous sert très bien. Il s'agit d'une bibliothèque Android qui envoie des rapports de plantage au serveur et au serveur qui reçoit les rapports et effectue des analyses. Le serveur regroupe les exceptions par nom d'exception, trace de pile, message. Il aide à identifier les problèmes les plus critiques qui doivent être résolus. Notre service est maintenant en version bêta publique afin que tout le monde puisse l'essayer. Vous pouvez créer un compte sur http://watchcat.co ou vous pouvez simplement voir comment cela fonctionne en utilisant l'accès démo http://watchcat.co/reports/index.php?demo .


3

Si vous voulez des réponses immédiatement, vous pouvez utiliser logcat

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

S'il y a trop de déchets dans votre journal en ce moment, essayez d'abord de les supprimer.

$adb shell logcat -c

Ensuite, essayez d'exécuter votre application, puis de nouveau logcat.


Cela ne nécessite-t-il pas encore de raccorder l'appareil à un PC (par exemple avec un câble)?
Gerard

3

J'ai trouvé une autre excellente application Web pour suivre les rapports d'erreur.

https://mint.splunk.com/

Petit nombre d'étapes à configurer.

  1. Connectez-vous ou inscrivez-vous et configurez en utilisant le lien ci-dessus. Une fois que vous avez créé une application, ils fourniront une ligne à configurer comme ci-dessous.
Mint.initAndStartSession(YourActivity.this, "api_key");
  1. Ajoutez ce qui suit dans le build.gradl de l'application.
android {
...
    repositories {
        maven { url "https://mint.splunk.com/gradle/"}
    }
...
}

dependencies {
...
    compile "com.splunk.mint:mint:4.4.0"
...
}
  1. Ajoutez le code que nous avons copié ci-dessus et ajoutez-le à chaque activité.

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

C'est ça. Vous vous connectez et accédez à votre tableau de bord d'application, vous obtiendrez tous les rapports d'erreur.

J'espère que cela aide quelqu'un.


Combien ça coûte?
user2966445

2

Pour un autre service de rapport d' incident / suivi des exceptions, consultez Raygun.io - il a un tas de logique agréable pour gérer les plantages Android, y compris une expérience utilisateur décente lors de la connexion à votre application (deux lignes de code dans votre activité principale et quelques lignes de XML collées dans AndroidManifest).

Lorsque votre application se bloque, elle récupère automatiquement la trace de la pile, les données d'environnement pour le matériel / logiciel, les informations de suivi des utilisateurs, toutes les données personnalisées que vous spécifiez, etc. Elle les publie de manière asynchrone dans l'API, donc pas de blocage du thread d'interface utilisateur, et les met en cache sur le disque s'il n'y a pas de réseau disponible.

Avertissement: j'ai construit le fournisseur Android :)


1

Je viens de commencer à utiliser ACRA https://github.com/ACRA/acra en utilisant Google Forms comme backend et c'est très facile à configurer et à utiliser, c'est la valeur par défaut.

MAIS L'envoi de rapports à Google Forms sera obsolète (puis supprimé): https://plus.google.com/118444843928759726538/posts/GTTgsrEQdN6 https://github.com/ACRA/acra/wiki/Notice-on-Google -Form-Spreadsheet-usage

Quoi qu'il en soit, il est possible de définir votre propre expéditeur https://github.com/ACRA/acra/wiki/AdvancedUsage#wiki-Implementing_your_own_sender vous pouvez par exemple essayer d'envoyer un e-mail à l'expéditeur.

Avec un minimum d'effort, il est possible d'envoyer des rapports à bugsense: http://www.bugsense.com/docs/android#acra

NB Le compte gratuit bugsense est limité à 500 rapports / mois


1

Tard dans la soirée, je soutiens et crois que l'ACRA est la meilleure option parmi toutes. C'est facile à installer et à configurer. J'ai créé un guide détaillé avec des entrées de partout pour récupérer le rapport de plantage en utilisant ACRA et l'envoyer par la poste à mon adresse e-mail en utilisant MandrillAp.

Lien vers l'article: https://androidician.wordpress.com/2015/03/29/sending-crash-reports-with-acra-over-email-using-mandrill/

Lien vers un exemple de projet sur github: https://github.com/ayushhgoyal/AcraSample


1

Je suis l'un des fondateurs de Bugsnag que nous avons conçu exactement dans ce but. Bugsnag capture automatiquement les exceptions non gérées dans les applications Android et les envoie à notre tableau de bord, où vous pouvez hiérarchiser les correctifs et plonger dans les informations de diagnostic.

Voici quelques éléments importants à prendre en compte lors de la sélection ou de la création d'un système de rapport d'incident, ainsi que des extraits de code:

  • Détecte automatiquement les exceptions non gérées ( exemple de code )
  • Collecte des données de diagnostic telles que l'utilisation de la mémoire, les informations sur l'appareil, etc. ( exemple de code )
  • Regroupe efficacement les plantages par cause première
  • Vous permet de suivre les actions que l'utilisateur a effectuées avant chaque crash pour faciliter la reproduction ( exemple de code )

Si vous souhaitez voir certaines des meilleures pratiques concernant la gestion des incidents / rapports sur Android, vous pouvez consulter le code source complet de la bibliothèque de rapports de crash de Bugsnag qui est entièrement open source, n'hésitez pas à la déchirer et à l'utiliser dans vos propres applications!


0

Si votre application est téléchargée par d'autres personnes et se bloque sur des appareils distants, vous souhaiterez peut-être consulter une bibliothèque de rapport d'erreurs Android (référencée dans cet article SO ). Si c'est uniquement sur votre propre appareil local, vous pouvez utiliser LogCat. Même si le périphérique n'était pas connecté à une machine hôte lorsque le crash s'est produit, la connexion du périphérique et l'émission d'une commande adb logcat téléchargeront l'intégralité de l'historique de logcat (au moins dans la mesure où il est mis en mémoire tampon, ce qui est généralement un loooot de données de journal , ce n'est tout simplement pas infini). L'une ou l'autre de ces options répond-elle à votre question? Si non, pouvez-vous essayer de clarifier un peu plus ce que vous recherchez?



0

Google a modifié le nombre de rapports d'erreur que vous obtenez réellement. Auparavant, vous ne disposiez que de rapports de bogues signalés manuellement.

Depuis la dernière conférence des développeurs et l'introduction d' Android Vitals, vous obtenez également des rapports de plantage d'utilisateurs qui ont permis de partager des données de diagnostic.

Vous verrez tous les plantages collectés à partir d'appareils Android dont les utilisateurs ont choisi de partager automatiquement les données d'utilisation et de diagnostic. Les données sont disponibles pour les deux mois précédents.

Afficher les plantages et les erreurs d'application ne répondant pas (ANR)


logcat dit qu'il y a un fichier de vidage sur incident en sortie dans /data/user/0/com.<myappname>/cache/WebView/Crash Report / <GUUID> .dmp, mais le périphérique n'est pas enraciné et je ne peux pas comprendre comment accéder à ce fichier!
Michael

0

Vous pouvez le faire directement dans Android Studio. Connectez simplement votre téléphone, exécutez l'application, laissez-la planter et vous pouvez afficher la trace de pile directement dans Android Studio.

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.