¿Cómo obtengo datos de fallas de mi aplicación de Android?


737

¿Cómo puedo obtener datos de fallas (trazas de pila al menos) de mi aplicación de Android? Al menos cuando trabajo en mi propio dispositivo siendo recuperado por cable, pero idealmente desde cualquier instancia de mi aplicación que se ejecute en la naturaleza para que pueda mejorarla y hacerla más sólida.



Veo que esto envía el informe a un servidor remoto. ¿Puede también registrar la excepción en un archivo local?

1
Informe de bloqueo de
gdonald

Este parece ser el más robusto, ¿qué pasa si el informe no se carga después de todos los reintentos, entonces puede registrarlo en un archivo o sqlite db?
JPM

Respuestas:


354

Puede probar la biblioteca ACRA (Application Crash Report para Android) :

ACRA es una biblioteca que permite que la aplicación de Android publique automáticamente sus informes de fallas en un formulario de GoogleDoc. Está dirigido a los desarrolladores de aplicaciones de Android para ayudarlos a obtener datos de sus aplicaciones cuando se bloquean o se comportan erróneamente.

Es fácil de instalar en su aplicación, altamente configurable y no requiere que aloje un script de servidor en ningún lugar ... ¡los informes se envían a una hoja de cálculo de Google Doc!


8
Esto es fácil de configurar y usar. Recomendado para el uso previo a la comercialización, e incluso posiblemente después.
mxcl

1
Comencé a usarlo y es inconmensurablemente mejor que el informe de errores en Flurry que tenía antes o el hecho en casa con el que comencé. Hasta ahora, estoy entusiasmado con "acra".
Adrian Spinei

8
La gran ventaja de acra es la posibilidad de utilizar las API de Google para analizar y visualizar fácilmente los datos; consulte jberkel.github.com/sms-backup-plus/acra-analysis para ver un ejemplo de cómo hacerlo.
Jan Berkel

3
Parece muy inestable para mí. El ACRA se bloqueó y envió un informe de bloqueo sobre sí mismo, no sobre el bloqueo de la aplicación relacionada. -1
Sandor

19
Google Docs como backend ya no es compatible
eliocs

305

Para aplicaciones de muestra y propósitos de depuración, utilizo una solución simple que me permite escribir el stacktrace en la tarjeta sd del dispositivo y / o subirlo a un servidor. Esta solución se ha inspirado en Project android-remote-stacktrace (específicamente, las partes de guardar en el dispositivo y cargar en el servidor) y creo que resuelve el problema mencionado por Soonil. No es óptimo, pero funciona y puede mejorarlo si desea usarlo en una aplicación de producción. Si decide cargar los stacktraces en el servidor, puede usar un script php ( index.php) para verlos. Si está interesado, puede encontrar todas las fuentes a continuación: una clase java para su aplicación y dos scripts php opcionales para el servidor que aloja los stacktraces cargados.

En un contexto (por ejemplo, la actividad principal), llame

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

99
Creo que esto causará problemas legales en algunos estados / países
setzamora

55
NOTA: HttpPost httpPost = new HttpPost(url);debe estar en una tarea asincrónica (o controlador ... un hilo separado) ahora si está apuntando a Honeycomb o más tarde
Bryan Denny

44
@Joset, ¿qué tipo de problemas legales y por qué?
varevarao

2
@varevarao Problemas legales (tal vez) porque está enviando información confidencial del dispositivo sin el consentimiento del usuario mediante el uso de la función Enviar a servidor de este código.
caw

2
El defaultExceptionHandler parece persistir en la recreación de la actividad. Actualicé la respuesta para establecer solo el valor predeterminado si un controlador personalizado aún no está configurado. Sin él, cada controlador retiene y llama al anterior, hasta llegar al original. Esto causa problemas con el registro duplicado, así como problemas de pérdida de memoria.
Dave McClelland el

57

También puedes probar [BugSense] Motivo: redireccionamiento de spam a otra url . BugSense recopila y analiza todos los informes de fallas y le brinda informes significativos y visuales. Es gratis y es solo una línea de código para integrarse.

Descargo de responsabilidad: soy cofundador


44
He probado BugSense y es increíble. Interfaz de usuario simple y fresca, muy rápida también. Sin estupideces hinchazón. Es fácil ver los bloqueos más frecuentes y también cavar en el stacktrace.
vidstige

Últimamente hacemos mucho más que informar de accidentes, pero este no es el lugar adecuado para hablar sobre nuevas funciones, etc.
PanosJee

Lo intenté. Los errores funcionaron aunque stacktrace no está demasiado completo, los datos de bloqueo en tiempo real no llegaron. El modo de depuración no funcionó. Sin embargo, seguí la ruta initialize-once desde la clase Application (que es lo que tiene sentido para la mayoría de los casos). BugSense tiene un tablero increíble, una lástima que por alguna razón los informes de fallas no funcionan y la simbolización no está en el nivel gratuito. Me llevó 5 minutos instalar GetSentry y simplemente funcionó de forma inmediata para Android con este cliente de uso general: github.com/joshdholtz/Sentry-Android
albertpeiro

3
BugSense es simple y fácil de integrar. PERO ES DEMASIADO CARO. Podemos lograr las mismas funcionalidades de detección de errores utilizando el análisis de Flurry y Parse. Ambos son gratuitos y fáciles de integrar.
venkat

44

En Android 2.2 ahora es posible obtener automáticamente informes de bloqueo de aplicaciones de Android Market:

La nueva función de informe de errores para las aplicaciones de Android Market permite a los desarrolladores recibir informes de bloqueo y congelación de sus usuarios. Los informes estarán disponibles cuando inicien sesión en su cuenta de editor.

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


Creo que no es solo 2.2, sino simplemente una nueva característica del mercado que ofrece Google. Recibí un informe de bloqueo hace unos días y no debería haber un dispositivo froyo usando mi aplicación.
Janusz

1
@ Janusz ¿Estás seguro? ya hay lanzamientos de Froyo para Nexus One, sin contar los Googlers que han estado ejecutando Froyo por un tiempo.
pupeno

Al menos debe haber una actualización en la versión en el teléfono, incluso es solo otra revisión, pero ¿cómo debería funcionar de otra manera?
RoflcoptrException

No sé si los informes se enviaron a Google antes. El informe es algo extraño porque Google muestra una interfaz de usuario para enviar sus videos y eso tiene que ser un cambio en el sistema operativo y no solo en el mercado. Pero dice: las plataformas 1 informan informes / semana y el droide no debería estar en Froyo.
Janusz

1
El código del botón "Informar" ha estado en el AOSP por un tiempo, y Romain Guy (vagamente) respondió una pregunta al respecto aquí hace un par de meses.
Christopher Orr

30

Es posible manejar estas excepciones con Thread.setDefaultUncaughtExceptionHandler(), sin embargo, esto parece alterar el método de manejo de excepciones de Android. Intenté usar un controlador de esta naturaleza:

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

Sin embargo, incluso al volver a lanzar las excepciones, no pude obtener el comportamiento deseado, es decir, registrar la excepción al tiempo que permitía que Android cerrara el componente que había sucedido, así que me di por vencido después de un tiempo.


¿Por qué solo vuelves a lanzar excepciones no marcadas? Me parece que deberías volver a lanzar todas las excepciones.
MatrixFrog

Parece que alguien tuvo éxito con su enfoque: jyro.blogspot.com/2009/09/crash-report-for-android-app.html
MatrixFrog

1
El truco consiste en obtener el UncaughtExceptionHandler predeterminado anterior y manejar la excepción a ese objeto después de que haya terminado de informar la excepción.
Tom

¿Forma Constants.TAGparte del marco de Android? Primera vez que lo veo. Parece que no puedo encontrarlo.
Haroun Hajem

1
@HarounHajem Necesitamos definir el nuestro.
KYHSGeekCode

22

Veo que la pregunta es demasiado antigua y espero que mi respuesta sea útil para otros que tengan el mismo problema ...

Prueba Crashlytics . Le dará una visión profunda de todos los bloqueos en todos los dispositivos que tienen su aplicación y le enviará una notificación por correo electrónico ... Y la mejor parte es que es completamente gratis.


21

Ok, bueno, miré las muestras proporcionadas por rrainn y Soonil, y encontré una solución que no estropea el manejo de errores.

Modifiqué el CustomExceptionHandler para que almacene el UncaughtExceptionHandler original del Hilo al que asociamos el nuevo. Al final del nuevo "uncaughtException" - Método, simplemente llamo a la función anterior usando el UncaughtExceptionHandler almacenado.

En la clase DefaultExceptionHandler necesitas algo. Me gusta esto:

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 esa modificación en el código en http://code.google.com/p/android-remote-stacktrace , tiene una buena base de trabajo para iniciar sesión en el campo en su servidor web o tarjeta SD.


19

Google Play Developers Console realmente te ofrece los rastros de Stack de esas aplicaciones que se han bloqueado y han enviado los informes, también tiene muy buenos gráficos para ayudarte a ver la información, mira el siguiente ejemplo:

ingrese la descripción de la imagen aquí


2
¿Cómo hace que los usuarios envíen los informes o cómo funciona exactamente si su aplicación no está en Play Store, puede hacerlo con fines de prueba?
Lion789

¿Sabes que hay algún proyecto de Android de código abierto que publique sus informes de fallos?
Justin Civi

1
Tenga en cuenta que esto mostrará solo los bloqueos, ANR que los usuarios eligieron informar
Sojin

Sí, de todos modos, cuando tienes una gran base de usuarios, tienes muchas posibilidades de que se notifiquen todos los bloqueos, y también los bloqueos y los ANR informados aquí serán los más importantes, porque la gente los informará más veces, para que así puedas filtrarlos y corregirlos en esa prioridad (más informes = error más importante) mientras que (sin informe = no ese error crítico).
Eefret

18

He estado usando Crittercism para mis aplicaciones de Android e iOS; escuché sobre ellas en techcrunch. Muy feliz con ellos hasta ahora!


FYI: los informes de fallas del lado NDK no son parte del plan básico y se encuentran en "Informes de fallas extendidas". Ver: crittercism.com/pricing
ahash

1
Acabo de probar los informes de NDK en Fabric.io Crashlytics de Twitter ... bastante bien (en el día 1 de uso), requirió un paso adicional cuando lancé para colocar el mapeo en su sistema para que los rastros de la pila se vean bien, pero se clavó el error NDK que solía probar (hizo una llamada "abortar ();" estratégicamente en todo c ++ y proporcionó un seguimiento de la pila para la prueba.
Hunter-Orionnoir


11

use esto para capturar los detalles de la excepción:

String stackTrace = Log.getStackTraceString(exception); 

almacenar esto en la base de datos y mantener el registro.


Cómo acceder a esa base de datos, ¿puede darme algún ejemplo? por favor si puedes gracias de antemano
Rajendra Verma

8

También puede usar un servicio completo (simple) en lugar de solo una biblioteca. Nuestra compañía acaba de lanzar un servicio solo para eso: http://apphance.com .

Tiene una biblioteca .jar simple (para Android) que agrega e integra en 5 minutos y luego la biblioteca recopila no solo información sobre fallas, sino también registros de la aplicación en ejecución, así como permite a sus evaluadores informar problemas directamente desde el dispositivo, incluido el contexto completo (rotación del dispositivo, ya sea que esté conectado a un wifi o no y más). Puede mirar los registros utilizando un panel web muy agradable y útil, donde puede realizar un seguimiento de las sesiones con su aplicación, bloqueos, registros, estadísticas y más. El servicio está en fase de prueba beta cerrada ahora, pero puede solicitar acceso y se lo daremos muy rápidamente.

Descargo de responsabilidad: soy CTO de Polidea y cocreador del servicio.


7

Agradezco los recursos presentes en Stackoverflowayudarme a encontrar esta respuesta.

Puede encontrar sus informes de fallas de Android de forma remota directamente en su correo electrónico . recuerda que debes poner tu correo electrónico dentro de la clase CustomExceptionHandler .

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

Pasos requeridos:

Primero) en onCreate of your activity use esta sección de su código.

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

2º) use esta versión anulada de la clase CustomExceptionHandler de (rrainn), de acuerdo con mi 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();

    }
}


5

Esto es muy bruto, pero es posible ejecutar logcat en cualquier lugar, por lo que se debe agregar un truco rápido y sucio a cualquier bloque de captura getRuntime().exec("logcat >> /sdcard/logcat.log");


Esto daría la salida de registro de todas las aplicaciones. Filtrar por el nombre de la etiqueta de la aplicación podría estar bien, pero no creo que sea una buena manera de hacerlo, ya que las entradas pueden ser acumulativas. Sin embargo, borrar el resultado de logcat después de cada escritura podría resolver ese problema.
bschandramohan

5

Existe una herramienta llamada fabric, esta es una herramienta analítica de fallas, que le permitirá obtener informes de fallas, cuando la aplicación se implemente en vivo y durante el desarrollo. Agregar esta herramienta a su aplicación también fue simple. Cuando su aplicación falla, el informe del bloqueo se puede ver desde su tablero de fabric.io. Este informe se capturó automáticamente. No le pedirá permiso al usuario. Si desea enviar el informe de error / bloqueo. Y esto es completamente gratis ... https://get.fabric.io/


5

Google Firebase es la última forma de Google (2016) de proporcionarle datos de fallas / errores en su teléfono. Inclúyalo en su archivo build.gradle:

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

Los bloqueos fatales se registran automáticamente sin requerir la intervención del usuario y también puede registrar bloqueos no fatales u otros eventos como este:

try
{

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

5

Existe esta biblioteca de Android llamada Sherlock . Le proporciona el informe completo del bloqueo junto con la información del dispositivo y la aplicación. Cada vez que ocurre un bloqueo, muestra una notificación en la barra de notificaciones y al hacer clic en la notificación, abre los detalles del bloqueo. También puede compartir detalles del bloqueo con otras personas por correo electrónico u otras opciones para compartir.

Instalación

android {
    dataBinding {
      enabled = true
    }
}

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

Manifestación

ingrese la descripción de la imagen aquí


5

Si bien muchas de las respuestas en esta página son útiles, es fácil que se desactualicen. El sitio web de AppBrain agrega estadísticas que le permiten encontrar la solución de informes de fallas más popular que es actual:

Bibliotecas de informes de fallos de Android

sitio web de cerebro de la aplicación

Puede ver que al momento de publicar esta imagen, Crashlytics se usa en el 5.24% de las aplicaciones y el 12.38% de las instalaciones.


4

Utilizamos nuestro sistema interno dentro de la empresa y nos sirve muy bien. Es una biblioteca de Android que envía informes de fallas al servidor y al servidor que recibe informes y realiza algunos análisis. El servidor agrupa las excepciones por nombre de excepción, stacktrace, mensaje. Ayuda a identificar los problemas más críticos que deben corregirse. Nuestro servicio está en versión beta pública ahora para que todos puedan probarlo. Puede crear una cuenta en http://watchcat.co o simplemente puede ver cómo funciona usando el acceso de demostración http://watchcat.co/reports/index.php?demo .


3

Si quiere respuestas de inmediato, puede usar logcat

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

Si hay demasiada basura en su registro en este momento, intente borrarlo primero.

$adb shell logcat -c

Luego intente ejecutar su aplicación y luego logcat nuevamente.


¿Todavía no requiere que conecte el dispositivo a una PC (por ejemplo, con un cable)?
Gerard

3

Encontré una gran aplicación web más para rastrear los informes de errores.

https://mint.splunk.com/

Pequeño número de pasos para configurar.

  1. Inicie sesión o regístrese y configure usando el enlace de arriba. Una vez que haya terminado de crear una aplicación, le proporcionarán una línea para configurar como se muestra a continuación.
Mint.initAndStartSession(YourActivity.this, "api_key");
  1. Agregue lo siguiente en la aplicación build.gradl.
android {
...
    repositories {
        maven { url "https://mint.splunk.com/gradle/"}
    }
...
}

dependencies {
...
    compile "com.splunk.mint:mint:4.4.0"
...
}
  1. Agregue el código que copiamos arriba y agréguelo a cada actividad.

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

Eso es. Inicie sesión y vaya al panel de la aplicación, obtendrá todos los informes de errores.

Espero que ayude a alguien.


¿Cuánto cuesta este?
user2966445

2

Para un servicio alternativo de informe de fallas / seguimiento de excepciones, consulte fallas Raygun.io : tiene una buena lógica para manejar los bloqueos de Android, incluida una experiencia de usuario decente al conectarlo a su aplicación (dos líneas de código en su Actividad principal y algunas líneas de XML pegadas en AndroidManifest).

Cuando su aplicación se bloquea, automáticamente capturará el seguimiento de la pila, los datos del entorno del hardware / software, la información de seguimiento del usuario, cualquier información personalizada que especifique, etc. La publicará en la API de forma asincrónica para que no se bloquee el hilo de la interfaz de usuario y la almacene en caché al disco si no hay red disponible.

Descargo de responsabilidad: construí el proveedor de Android :)


1

Recién comencé a usar ACRA https://github.com/ACRA/acra usando Google Forms como back-end y es muy fácil de configurar y usar, es el valor predeterminado.

PERO el envío de informes a los formularios de Google quedará en desuso (luego se eliminará): https://plus.google.com/118444843928759726538/posts/GTTgsrEQdN6 https://github.com/ACRA/acra/wiki/Notice-on-Google -Formulario-Hoja de cálculo-uso

De todos modos, es posible definir su propio remitente https://github.com/ACRA/acra/wiki/AdvancedUsage#wiki-Implementing_your_own_sender , puede intentar enviar un correo electrónico al remitente, por ejemplo.

Con un mínimo esfuerzo es posible enviar informes a bugsense: http://www.bugsense.com/docs/android#acra

Nota : la cuenta gratuita de bugsense está limitada a 500 informes / mes


1

Tarde a la fiesta, apoyo y creo que ACRA es la mejor opción entre todas. Es fácil de configurar y configurar. He creado una guía detallada con entradas de todas partes para buscar el informe de falla usando ACRA y enviarlo por correo a mi dirección de correo electrónico usando MandrillAp.

Enlace a la publicación: https://androidician.wordpress.com/2015/03/29/sending-crash-reports-with-acra-over-email-using-mandrill/

Enlace al proyecto de muestra en github: https://github.com/ayushhgoyal/AcraSample


1

Soy uno de los fundadores de Bugsnag, que diseñamos exactamente para este propósito. Bugsnag captura automáticamente las excepciones no controladas en las aplicaciones de Android y las envía a nuestro panel de control, donde puede priorizar las soluciones y sumergirse en la información de diagnóstico.

Estas son algunas cosas importantes a tener en cuenta al seleccionar o crear un sistema de informe de fallos, junto con algunos fragmentos de código:

  • Detecta excepciones no manejadas automáticamente ( código de ejemplo )
  • Recopila datos de diagnóstico como el uso de memoria, información del dispositivo, etc. ( código de ejemplo )
  • Agrupa efectivamente los choques por causa raíz
  • Le permite realizar un seguimiento de las acciones que realizó el usuario antes de cada bloqueo para ayudar a reproducir ( código de ejemplo )

Si desea ver algunas de las mejores prácticas sobre el manejo / informe de fallas en Android, puede consultar el código fuente completo de la biblioteca de informes de fallas de Bugsnag que es de código abierto, ¡no dude en separar esto y usarlo en sus propias aplicaciones!


0

Si otras personas descargan su aplicación y se bloquea en dispositivos remotos, es posible que desee buscar en una biblioteca de informes de errores de Android (mencionada en esta publicación SO ). Si solo está en su propio dispositivo local, puede usar LogCat. Incluso si el dispositivo no estaba conectado a una máquina host cuando se produjo el bloqueo, al conectar el dispositivo y al emitir un comando adb logcat se descargará todo el historial de logcat (al menos en la medida en que está almacenado en el búfer, que suele ser una gran cantidad de datos de registro) , simplemente no es infinito). ¿Alguna de esas opciones responde a su pregunta? Si no, ¿puedes intentar aclarar un poco más lo que estás buscando?



0

Google cambió la cantidad de informes de fallos que realmente recibes. Anteriormente solo recibías informes de errores informados manualmente.

Desde la última conferencia de desarrolladores y la presentación de Android Vitals , también recibe informes de fallas de los usuarios que han permitido compartir datos de diagnóstico.

Verá todos los bloqueos recopilados de los dispositivos Android cuyos usuarios han optado por compartir automáticamente los datos de uso y diagnóstico. Los datos están disponibles para los dos meses anteriores.

Ver fallas y errores de aplicación que no responde (ANR)


logcat dice que hay un archivo de volcado de caída de salida en /data/user/0/com.<myappname>/cache/WebView/Crash Report / <GUUID> .dmp, pero el dispositivo no está rooteado y no puedo entender ¡Cómo acceder a este archivo!
Michael

0

Puedes hacer esto directamente en Android Studio. Simplemente conecte su teléfono, ejecute la aplicación, deje que se bloquee y podrá ver el seguimiento de la pila directamente en Android Studio.

Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.