Como obtenho dados de falha do meu aplicativo Android?


737

Como posso obter dados de falha (rastreios de pilha pelo menos) do meu aplicativo Android? Pelo menos ao trabalhar no meu próprio dispositivo sendo recuperado por cabo, mas idealmente a partir de qualquer instância do meu aplicativo em execução no ambiente, para que eu possa melhorá-lo e torná-lo mais sólido.



Vejo que isso envia o relatório para um servidor remoto. Também pode registrar a exceção em um arquivo local?

1
Relatório de falha de aplicativo para Android code.google.com/p/acra
gdonald 04/08/11

Este parece ser o mais robusto; e se o relatório não for carregado após todas as novas tentativas, ele poderá registrá-lo em arquivo ou no sqlite db?
JPM

Respostas:


354

Você pode experimentar a biblioteca do ACRA (Application Crash Report for Android) :

A ACRA é uma biblioteca que permite ao Aplicativo Android publicar automaticamente seus relatórios de falhas em um formulário do GoogleDoc. Ele é direcionado aos desenvolvedores de aplicativos Android para ajudá-los a obter dados de seus aplicativos quando eles travam ou se comportam de maneira incorreta.

É fácil de instalar no seu aplicativo, altamente configurável e não exige que você hospede um script de servidor em qualquer lugar ... os relatórios são enviados para uma planilha do Google Doc!


8
É fácil de configurar e usar. Recomendado para uso no pré-mercado e até mesmo depois.
Mxcl

1
Comecei a usá-lo e é incomensuravelmente melhor do que o relatório de erros no Flurry que eu tinha antes ou o caseiro com o qual eu comecei. Até agora, estou muito feliz com o "acra".
Adrian Spinei

8
A grande vantagem do acra é a possibilidade de usar as APIs do Google para analisar e visualizar facilmente os dados, consulte jberkel.github.com/sms-backup-plus/acra-analysis para obter um exemplo de como fazer isso.
Jan Berkel

3
Parece muito instável para mim. A própria ACRA caiu e enviou um relatório de falha sobre si mesma, não a falha do aplicativo relacionado. -1
Sandor

19
O Google Docs como back-end não é mais suportado
eliocs

305

Para aplicativos de amostra e propósitos de depuração, uso uma solução simples que permite gravar o rastreamento de pilha no cartão sd do dispositivo e / ou enviá-lo para um servidor. Essa solução foi inspirada no Project android-remote-stacktrace (especificamente, nas partes salvar no dispositivo e fazer upload no servidor) e acho que resolve o problema mencionado por Soonil. Não é o ideal, mas funciona e você pode aprimorá-lo se quiser usá-lo em um aplicativo de produção. Se você decidir fazer upload dos rastreamentos de pilha no servidor, poderá usar um script php ( index.php) para visualizá-los. Se você estiver interessado, poderá encontrar todas as fontes abaixo - uma classe java para seu aplicativo e dois scripts php opcionais para o servidor que hospeda os stacktraces carregados.

Em um contexto (por exemplo, a atividade principal), chame

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
Acho que isso vai causar problemas legais em alguns estados / países
setzamora

5
NOTA: HttpPost httpPost = new HttpPost(url);deve estar em uma tarefa assíncrona (ou manipulador ... um segmento separado) agora se você está direcionando Honeycomb ou mais tarde
Bryan Denny

4
@ Joset, que tipo de questões legais e por quê?
varevarao

2
@varevarao Problemas legais (talvez) porque você está enviando informações confidenciais do dispositivo sem o consentimento do usuário, usando o recurso Enviar para o servidor deste código.
caw

2
O defaultExceptionHandler parece persistir na recreação de atividades. Atualizei a resposta para definir o padrão apenas se um manipulador personalizado ainda não estiver definido. Sem ele, cada manipulador mantém e chama o anterior, até o original. Isso causa problemas com o log duplicado e também com problemas de vazamento de memória.
21813 Dave McClelland

57

Você também pode experimentar o [BugSense] Motivo: redirecionamento de spam para outro URL . O BugSense coleta e analisa todos os relatórios de falhas e fornece relatórios visuais e significativos. É gratuito e possui apenas 1 linha de código para integrar.

Disclaimer: Eu sou um co-fundador


4
Eu tentei o BugSense e é incrível. UI simples e atualizada, muito rápida também. Nenhum recurso estúpido inchaço. É fácil ver as falhas mais frequentes e também cavar o rastreamento de pilha.
vidstige

Nós recentemente fazer muito mais do que apenas relatórios Bater, mas este não é o lugar certo para falar novas funcionalidades etc.
PanosJee

Tentei. Erros funcionaram, embora o stacktrace não seja muito completo, os dados de travamento em tempo real não chegaram. O modo de depuração não funcionou. No entanto, desci a rota inicializar uma vez da classe Application (que é o que faz sentido para a maioria dos casos). O BugSense possui um painel incrível, uma pena que, por algum motivo, os relatórios de falhas não funcionem e a simbolização não esteja no nível gratuito. Me levou 5 minutos para instalar GetSentry e ele só trabalhou fora da caixa para o Android com este cliente de propósito geral: github.com/joshdholtz/Sentry-Android
albertpeiro

3
O BugSense é simples e fácil de integrar. MAS É MUITO CARO. Podemos obter as mesmas funcionalidades de detecção de erros usando a análise Flurry e o Parse. Ambos são gratuitos e fáceis de integrar.
venkat 27/02

44

No Android 2.2, agora é possível obter automaticamente os Relatórios de falhas a partir dos aplicativos do Android Market:

O novo recurso de relatório de erros dos aplicativos Android Market permite que os desenvolvedores recebam relatórios de travamentos e congelamentos de seus usuários. Os relatórios estarão disponíveis quando eles fizerem login na conta do editor.

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


Eu acho que não é apenas o 2.2, mas simplesmente um novo recurso de mercado que o Google oferece. Recebi um relatório de falha há alguns dias e não deveria haver um dispositivo froyo por aí usando meu aplicativo.
Janusz

1
@Janusz Você tem certeza? já existem versões do Froyo para o Nexus One, sem contar os Googlers que estão executando o Froyo há algum tempo.
pupeno 28/05

Pelo menos deve haver uma atualização na versão do telefone, mesmo que seja apenas mais uma revisão, mas como isso deve funcionar de outra maneira?
RoflcoptrException

Não sei se os relatórios foram enviados para o Google antes. O relatório é um pouco estranho, porque o Google mostra uma interface do usuário para enviar seus vídeos e isso deve ser uma mudança no sistema operacional e não apenas no mercado. Mas ele diz: As plataformas 1 relatam relatórios / semana e o dróide não deve estar no froyo.
Janusz

1
O código do botão "Relatório" está no AOSP há um tempo, e Romain Guy (vagamente) respondeu uma pergunta sobre isso aqui há alguns meses.
Christopher Orr

30

É possível lidar com essas exceções Thread.setDefaultUncaughtExceptionHandler(), mas isso parece mexer com o método do Android de lidar com exceções. Eu tentei usar um manipulador dessa natureza:

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

No entanto, mesmo com o relançamento das exceções, não consegui obter o comportamento desejado, ou seja, registrei a exceção e, ao mesmo tempo, permiti que o Android desligasse o componente que havia acontecido, por isso desisti depois de um tempo.


Por que você está apenas lançando exceções não verificadas? Parece-me que você deve relançar todas as exceções.
MatrixFrog

Parece que alguém conseguiu com a sua abordagem: jyro.blogspot.com/2009/09/crash-report-for-android-app.html
MatrixFrog

1
O truque é obter o UncaughtExceptionHandler padrão anterior e manipular a exceção para esse objeto depois que você terminar de relatar a exceção.
Tom

Faz Constants.TAGparte da estrutura do Android? Primeira vez que vi isso. Não consigo encontrar.
Haroun Hajem

1
@HarounHajem Precisamos definir os nossos.
KYHSGeekCode

22

Vejo que a pergunta é muito antiga e espero que minha resposta seja útil para outras pessoas com o mesmo problema ...

Experimente o Crashlytics . Ele fornecerá informações detalhadas sobre todas as falhas em todos os dispositivos que possuem seu aplicativo e enviará uma notificação por e-mail. E a melhor parte é totalmente gratuito para uso.


21

Ok, olhei as amostras fornecidas pela rrainn e Soonil e encontrei uma solução que não atrapalha o tratamento de erros.

Modifiquei o CustomExceptionHandler para que ele armazene o UncaughtExceptionHandler original do Thread que associamos ao novo. No final do novo "uncaughtException" - Método, chamo a função antiga usando o UncaughtExceptionHandler armazenado.

Na classe DefaultExceptionHandler, você precisa de sth. como isso:

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

Com essa modificação no código em http://code.google.com/p/android-remote-stacktrace, você tem uma boa base de trabalho para fazer logon no campo no servidor da web ou no cartão SD.


19

O Google Play Developers Console, na verdade, fornece os rastreamentos de pilha dos aplicativos que falharam e enviaram os relatórios; também possui gráficos muito bons para ajudá-lo a ver as informações, veja o exemplo abaixo:

insira a descrição da imagem aqui


2
Como os usuários enviam os relatórios ou como isso funciona exatamente se o aplicativo não está na loja de jogos, você pode fazer isso para fins de teste?
precisa saber é o seguinte

Você sabia que existe algum projeto Android de código aberto que publique seus relatórios de falhas?
23615 Justin Civi

1
Observe que isso mostrará apenas as falhas, ANR que os usuários optaram por relatar
sojin

Sim, de qualquer maneira, quando você tem uma grande base de usuários, há muitas possibilidades de todas as falhas serem relatadas, e também as falhas e as ANR relatadas aqui serão as mais importantes, porque as pessoas as reportarão mais vezes, para que você possa filtre e corrija-os nessa prioridade (mais relatórios = bug mais importante) enquanto (nenhum relatório = bug não crítico).
Eefret

18

Eu uso o Crittercism para meus aplicativos Android e iOS - ouvi falar deles no TechCrunch. Muito feliz com eles até agora!


Para sua informação: os relatórios de falhas do lado do NDK não fazem parte do plano básico e estão em "Relatório de falhas estendidas". Veja: crittercism.com/pricing
ahash

1
Acabei de testar o relatório NDK no Fabric.io Crashlytics do Twitter ... ótimo (no dia 1 de uso), foi necessária uma etapa extra ao liberar para colocar o mapeamento em seu sistema para que os rastreamentos de pilha pareçam bons, mas acertaram em cheio o erro NDK eu usei para teste (fez uma "abort ();" chamar estrategicamente em todo o c ++ e forneceu um rastreamento de pilha para testar.
Hunter-Orionnoir


11

use isso para capturar os detalhes da exceção:

String stackTrace = Log.getStackTraceString(exception); 

armazene isso no banco de dados e mantenha o log.


Como acessar essa base de dados, você me dará algum exemplo. por favor, se puder. obrigado em advacne
Rajendra Verma

8

Você também pode usar um serviço (simples) completo para ele, em vez de apenas uma biblioteca. Nossa empresa acaba de lançar um serviço exatamente para isso: http://apphance.com .

Possui uma biblioteca .jar simples (para Android) que você adiciona e integra em 5 minutos e, em seguida, a biblioteca reúne não apenas informações de falha, mas também logs do aplicativo em execução, além de permitir que os testadores relatem problemas diretamente do dispositivo - incluindo o contexto inteiro (rotação do dispositivo, esteja ele conectado a um wifi ou não e mais). Você pode ver os logs usando um painel da Web muito agradável e útil, onde pode acompanhar sessões com seu aplicativo, falhas, logs, estatísticas e muito mais. O serviço está em fase de teste beta fechado agora, mas você pode solicitar acesso e nós o fornecemos muito rapidamente.

Isenção de responsabilidade: Sou CTO da Polidea e co-criador do serviço.


7

Graças aos recursos presentes, Stackoverflowajudando-me a encontrar esta resposta.

Você pode encontrar seus relatórios de falhas remotamente Android diretamente em seu e-mail . Lembre-se de que você deve colocar seu email na classe CustomExceptionHandler .

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

Etapas necessárias:

1º) no onCreate de sua atividade, use esta seção do seu código.

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

2) use esta versão substituída da classe CustomExceptionHandler de (rrainn), de acordo com meu 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

Isso é muito bruto, mas é possível executar o logcat em qualquer lugar, portanto, um hack rápido e sujo é adicionado a qualquer bloco de captura getRuntime().exec("logcat >> /sdcard/logcat.log");


Isso daria a saída do log de todos os aplicativos. A filtragem pelo nome da tag do aplicativo pode ser boa, mas não pense que esse seria um bom caminho, pois as entradas podem ser cumulativas. A limpeza da saída do logcat após cada gravação pode resolver esse problema.
bschandramohan

5

Existe uma ferramenta chamada fabric, que é uma ferramenta de análise de falhas, que permite obter relatórios de falhas quando o aplicativo é implementado ao vivo e durante o desenvolvimento. A adição desta ferramenta ao seu aplicativo também foi simples. Quando o seu aplicativo falha, o relatório da falha pode ser visualizado no painel fabric.io. o relatório foi capturado automaticamente. não solicitará permissão ao usuário. Se ele / ela deseja enviar o relatório de erro / falha. E isso é totalmente gratuito ... https://get.fabric.io/


5

O Google Firebase é a maneira mais recente (2016) do Google de fornecer dados de falha / erro no seu telefone. Inclua-o no arquivo build.gradle:

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

Falhas fatais são registradas automaticamente sem a necessidade de entrada do usuário e você também pode registrar falhas não fatais ou outros eventos como:

try
{

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

5

Existe esta biblioteca Android chamada Sherlock . Ele fornece o relatório completo de falha, além de informações sobre o dispositivo e o aplicativo. Sempre que ocorre uma falha, ele exibe uma notificação na barra de notificação e, ao clicar nela, abre os detalhes da falha. Você também pode compartilhar detalhes da falha com outras pessoas por e-mail ou outras opções de compartilhamento.

Instalação

android {
    dataBinding {
      enabled = true
    }
}

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

Demo

insira a descrição da imagem aqui


5

Embora muitas das respostas desta página sejam úteis, é fácil para elas ficarem desatualizadas. O site do AppBrain agrega estatísticas que permitem encontrar a solução de relatório de falhas mais popular atualmente:

Bibliotecas de relatórios de falhas do Android

site do cérebro do aplicativo

Você pode ver que, no momento da publicação desta imagem, o Crashlytics é usado em 5,24% dos aplicativos e 12,38% das instalações.


4

Utilizamos nosso sistema interno dentro da empresa e isso nos serve muito bem. É uma biblioteca Android que envia relatórios de falhas para o servidor e servidor que recebe relatórios e faz algumas análises. O servidor agrupa exceções por nome da exceção, rastreamento de pilha, mensagem. Ajuda a identificar os problemas mais críticos que precisam ser corrigidos. Nosso serviço está em versão beta pública agora, para que todos possam experimentá-lo. Você pode criar uma conta em http://watchcat.co ou pode simplesmente ver como funciona usando o acesso demo http://watchcat.co/reports/index.php?demo .


3

Se você deseja respostas imediatamente, pode usar o logcat

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

Se houver muito lixo no seu log agora, tente limpá-lo primeiro.

$adb shell logcat -c

Em seguida, tente executar o aplicativo e faça o logcat novamente.


Isso ainda não requer que você conecte o dispositivo a um PC (por exemplo, com um cabo)?
Gerard

3

Encontrei mais um ótimo aplicativo da web para rastrear os relatórios de erros.

https://mint.splunk.com/

Pequeno número de etapas para configurar.

  1. Entre ou inscreva-se e configure usando o link acima. Depois de criar um aplicativo, eles fornecerão uma linha para configurar como abaixo.
Mint.initAndStartSession(YourActivity.this, "api_key");
  1. Adicione o seguinte no build.gradl do aplicativo.
android {
...
    repositories {
        maven { url "https://mint.splunk.com/gradle/"}
    }
...
}

dependencies {
...
    compile "com.splunk.mint:mint:4.4.0"
...
}
  1. Adicione o código que copiamos acima e adicione-o a todas as atividades.

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

É isso aí. Ao fazer o login e acessar o painel do aplicativo, você receberá todos os relatórios de erros.

Espero que ajude alguém.


Quanto custa isso?
precisa saber é o seguinte

2

Para um serviço alternativo de relatório de falhas / rastreamento de exceções, confira Raygun.io - ele tem várias lógicas legais para lidar com falhas do Android, incluindo uma experiência decente do usuário ao conectá-las ao seu aplicativo (duas linhas de código na sua Atividade principal e algumas linhas de XML coladas no AndroidManifest).

Quando o aplicativo falha, ele pega automaticamente o rastreamento da pilha, os dados do ambiente para o hardware / software, as informações de rastreamento do usuário, quaisquer dados personalizados que você especificar etc. Ele o envia para a API de forma assíncrona, sem bloqueio do encadeamento da interface do usuário, e o armazena em cache. para o disco se não houver rede disponível.

Isenção de responsabilidade: criei o provedor Android :)


1

Apenas começou a usar o ACRA https://github.com/ACRA/acra usando o Google Forms como back-end e é muito fácil de configurar e usar, é o padrão.

MAS O envio de relatórios para o Google Forms será preterido (depois removido): https://plus.google.com/118444843928759726538/posts/GTTgsrEQdN6 https://github.com/ACRA/acra/wiki/Notice-on-Google -Form-Spreadsheet-use

De qualquer forma, é possível definir seu próprio remetente https://github.com/ACRA/acra/wiki/AdvancedUsage#wiki-Implementing_your_own_sender Você pode tentar enviar um e-mail ao remetente, por exemplo.

Com o mínimo esforço, é possível enviar relatórios para o bugsense: http://www.bugsense.com/docs/android#acra

NB A conta gratuita do bugsense é limitada a 500 relatórios / mês


1

Tarde para a festa, apoio e acredito que a ACRA é a melhor opção entre todas. É fácil de instalar e configurar. Criei um guia detalhado com entradas de todo o país para buscar o relatório de falha usando o ACRA e enviar o mesmo para o meu endereço de e-mail usando o MandrillAp.

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

Link para amostra de projeto no github: https://github.com/ayushhgoyal/AcraSample


1

Eu sou um dos fundadores da Bugsnag que projetamos exatamente para esse fim. O Bugsnag captura automaticamente exceções não tratadas em aplicativos Android e as envia para o nosso painel, onde você pode priorizar correções e mergulhar nas informações de diagnóstico.

Aqui estão algumas coisas importantes a considerar ao selecionar ou criar um sistema de relatório de falhas, junto com alguns trechos de código:

  • Detecta exceções não tratadas automaticamente ( código de exemplo )
  • Coleta dados de diagnóstico, como uso de memória, informações do dispositivo etc. ( código de exemplo )
  • Agrupa efetivamente as falhas por causa raiz
  • Permite rastrear ações que o usuário executou antes de cada falha para ajudar a reproduzir ( código de exemplo )

Se você quiser ver algumas práticas recomendadas em relação ao tratamento / relatório de falhas no Android, confira o código-fonte completo da biblioteca de relatórios de falhas do Bugsnag, que é totalmente aberta, sinta-se à vontade para separar isso e usá-lo em seus próprios aplicativos!


0

Se o aplicativo estiver sendo baixado por outras pessoas e travando em dispositivos remotos, convém consultar uma biblioteca de relatórios de erros do Android (mencionada nesta postagem do SO ). Se for apenas no seu próprio dispositivo local, você pode usar o LogCat. Mesmo que o dispositivo não tenha sido conectado a uma máquina host quando ocorreu a falha, o dispositivo conectado e a emissão de um comando adb logcat farão o download de todo o histórico do logcat (pelo menos na medida em que estiver em buffer, o que geralmente é uma quantidade imensa de dados de log , simplesmente não é infinito). Alguma dessas opções responde à sua pergunta? Caso contrário, você pode tentar esclarecer um pouco mais o que está procurando?



0

O Google mudou a quantidade de relatórios de falhas que você realmente recebe. Anteriormente, você só recebia relatórios de erros reportados manualmente.

Desde a última conferência do desenvolvedor e a introdução do Android Vitals, você também recebe relatórios de falhas de usuários que ativaram o compartilhamento de dados de diagnóstico.

Você verá todas as falhas coletadas em dispositivos Android cujos usuários optaram por compartilhar automaticamente dados de uso e diagnóstico. Os dados estão disponíveis para os dois meses anteriores.

Ver falhas e erros de aplicação não respondendo (ANR)


O logcat está dizendo que há um arquivo de despejo de memória de saída em /data/user/0/com.<myappname>/cache/WebView/Crash Report / <GUUID> .dmp, mas o dispositivo não está enraizado e não consigo entender como acessar esse arquivo!
Michael

0

Você pode fazer isso diretamente no Android Studio. Basta conectar seu telefone, executar o aplicativo, deixá-lo travar e você pode visualizar o rastreamento de pilha diretamente no Android Studio.

Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.