Android Log.v (), Log.d (), Log.i (), Log.w (), Log.e () - Quando usar cada um?

Os diferentes LogCatmétodos são:

Log.v(); // Verbose
Log.d(); // Debug
Log.i(); // Info
Log.w(); // Warning
Log.e(); // Error

Quais são as situações apropriadas para usar cada tipo de log? Eu sei que talvez seja apenas um pouco de semântica e talvez isso realmente não importe, mas para LogCatfiltrar no Android Studio e Eclipse, seria bom saber que estou usando os métodos adequados nos momentos apropriados.

Vamos na ordem inversa:

• Log.e : É para quando coisas ruins acontecem. Use essa tag em locais como dentro de uma instrução catch. Você sabe queocorreuum erro e, portanto, está registrando um erro.

• Log.w : use isso quando suspeitar que algo obscuro está acontecendo. Você pode não estar completamente cheio no modo de erro, mas talvez tenha se recuperado de algum comportamento inesperado. Basicamente, use isso para registrar coisas que você não esperava que acontecessem, mas não é necessariamente um erro. Mais ou menos como "ei, isso aconteceu, e é estranho , devemos investigar".

• Log.i : use para publicar informações úteisno log. Por exemplo: que você se conectou com sucesso a um servidor. Basicamente, use-o para relatar sucessos.

• Log.d : use isso parafins de depuração . Se você quiser imprimir várias mensagens para poder registrar o fluxo exato do seu programa, use isso. Se você deseja manter um log de valores de variáveis, use isso.

• Log.v : use isso quando desejar ficar absolutamente louco com o seu log. Se, por algum motivo, você decidiu registrar tudo em uma parte específica do seu aplicativo, use a tag Log.v.

E como um bônus ...

• Log.wtf : use isso quando as coisas derem absolutamente, horrivelmente errado. Você conhece aqueles blocos de captura onde você está pegando erros que você nunca deve obter ... sim, se você quiser registrá-los, use Log.wtf

Os diferentes métodos são indicações de prioridade. Como você os listou, eles vão do menos para o mais importante. Eu acho que como você os mapeia especificamente para logs de depuração no seu código depende do componente ou aplicativo no qual você está trabalhando, bem como como o Android os trata em diferentes tipos de compilação (eng, userdebug e user). Eu trabalhei bastante nos daemons nativos no Android, e é assim que faço. Pode não se aplicar diretamente ao seu aplicativo, mas pode haver algum ponto em comum. Se minha explicação parece vaga, é porque parte disso é mais uma arte do que uma ciência. Minha regra básica é ser o mais eficiente possível, garantir que você possa depurar razoavelmente seu componente sem prejudicar o desempenho do sistema e sempre verificar erros e registrá-los.

V - Impressões de estado em diferentes intervalos ou em eventos que meu componente processe. Também, possivelmente, impressões muito detalhadas das cargas úteis de mensagens / eventos que meu componente recebe ou envia.

D - Detalhes de eventos secundários que ocorrem dentro do meu componente, bem como cargas úteis de mensagens / eventos que meu componente recebe ou envia.

I - O cabeçalho de todas as mensagens / eventos que meu componente recebe ou envia, bem como quaisquer partes importantes da carga útil que são críticas para a operação do meu componente.

W - Tudo o que acontece é incomum ou suspeito, mas não necessariamente um erro.

E - Erros, significando coisas que não deveriam acontecer quando as coisas estão funcionando como deveriam.

O maior erro que vejo as pessoas cometem é que elas usam demais coisas como V, D e eu, mas nunca usam W ou E. Se um erro é, por definição, não deveria acontecer, ou deveria acontecer muito raramente, então é extremamente barato registrar uma mensagem quando ela ocorrer. Por outro lado, se toda vez que alguém pressiona uma tecla você faz um Log.i (), você está abusando do recurso de log compartilhado. Obviamente, use o bom senso e tenha cuidado com os logs de erros para coisas fora do seu controle (como erros de rede) ou aqueles contidos em loops apertados.

Talvez Ruim

Log.i("I am here");

Boa

Log.e("I shouldn't be here");

Com tudo isso em mente, quanto mais próximo o código estiver da "produção pronta", mais você poderá restringir o nível de log de base do seu código (você precisará de V em alfa, D em beta, I em produção ou possivelmente até W em produção ) Você deve executar alguns casos de uso simples e visualizar os logs para garantir que você ainda possa entender principalmente o que está acontecendo ao aplicar uma filtragem mais restritiva. Se você executar o filtro abaixo, ainda poderá saber o que seu aplicativo está fazendo, mas talvez não obtenha todos os detalhes.

logcat -v threadtime MyApp:I *:S

O código fonte fornece algumas orientações básicas:

A ordem em termos de verbosidade, do menor para o mais, é ERROR, WARN, INFO, DEBUG, VERBOSE. O verboso nunca deve ser compilado em um aplicativo, exceto durante o desenvolvimento. Os logs de depuração são compilados, mas removidos em tempo de execução. Os registros de erro, aviso e informações são sempre mantidos.

Para mais detalhes, a resposta de Kurtis está morta. Gostaria apenas de acrescentar: Não registre nenhuma informação pessoal ou identificável pessoalmente INFOou acima ( WARN/ ERROR). Caso contrário, os relatórios de erros ou qualquer outra coisa que inclua o registro podem ser poluídos.

Você pode usar o LOG, como:

Log.e(String, String) (error)
Log.w(String, String) (warning)
Log.i(String, String) (information)
Log.d(String, String) (debug)
Log.v(String, String) (verbose)

código de exemplo:

private static final String TAG = "MyActivity";
...
Log.i(TAG, "MyClass.getView() — get item number " + position);

Acho que o objetivo desses diferentes tipos de log é se você deseja que seu aplicativo basicamente filtre seus próprios logs. Portanto, a Verbose pode registrar absolutamente tudo de importância no seu aplicativo, o nível de depuração registrará um subconjunto dos logs detalhados e, em seguida, o nível Info registrará um subconjunto dos logs de depuração. Quando você acessa os logs de erros, deseja registrar qualquer tipo de erro que possa ter ocorrido. Há também um nível de depuração chamado Fatal para quando algo realmente atinge o ventilador no seu aplicativo.

Em geral, você está certo, é basicamente arbitrário, e cabe a você definir o que é considerado um log de depuração versus informativo, versus e erro, etc. etc.

Mesmo que essa pergunta já tenha sido respondida, sinto que faltam exemplos na resposta que foi respondida.

Portanto, vou trazer aqui o que escrevi em uma postagem no blog "Níveis de log do Android"

Verbose

É o nível mais baixo de log. Se você quiser enlouquecer com o registro, então você segue com esse nível. Eu nunca entendi quando usar o Verbose e quando usar o Debug. A diferença me pareceu muito arbitrária. Finalmente entendi uma vez que fui apontado para o código fonte do Android¹ "O Verbose nunca deve ser compilado em um aplicativo, exceto durante o desenvolvimento". Agora está claro para mim, sempre que você estiver desenvolvendo e quiser adicionar logs excluídos que o ajudem durante o desenvolvimento, é útil ter um nível detalhado, o que ajudará a excluir todos esses logs antes de entrar em produção.

Depurar

É para fins de depuração. Este é o nível mais baixo que deve estar em produção. As informações aqui estão para ajudar durante o desenvolvimento. Na maioria das vezes, você desabilita essa produção de logon para que menos informações sejam enviadas e somente habilite esse log se houver algum problema. Eu gosto de fazer login para depurar todas as informações que o aplicativo envia / recebe do servidor (tome cuidado para não registrar senhas !!!). Isso é muito útil para entender se o bug está no servidor ou no aplicativo. Também faço registros de entrada e saída de funções importantes.

Informações

Para mensagens informativas que destacam o progresso do aplicativo. Por exemplo, quando a inicialização do aplicativo estiver concluída. Adicione informações quando o usuário se mover entre atividades e fragmentos. Registre cada chamada de API, mas apenas poucas informações como URL, status e tempo de resposta.

Aviso

Quando há uma situação potencialmente prejudicial.

Este registro é, na minha experiência, um nível complicado. Quando você tem uma situação potencialmente prejudicial? Em geral ou se está OK ou se é um erro. Eu pessoalmente não uso muito esse nível. Exemplos de quando eu uso geralmente são quando as coisas acontecem várias vezes. Por exemplo, um usuário tem uma senha errada mais de 3 vezes. Isso pode ter acontecido porque ele digitou a senha incorretamente três vezes, ou porque há um problema com um caractere que não está sendo aceito em nosso sistema. O mesmo acontece com os problemas de conexão de rede.

Erro

Eventos de erro. O aplicativo ainda pode continuar em execução após o erro. Pode ser, por exemplo, quando recebo um ponteiro nulo, onde não devo obtê-lo. Ocorreu um erro ao analisar a resposta do servidor. Ocorreu um erro do servidor.

WTF (que falha terrível)

Fatal é para eventos de erro graves que levarão o aplicativo a sair. No Android, o fatal é, na realidade, o nível de erro, a diferença é que ele também adiciona o fullstack.

O site do Android Studio recentemente (acho) forneceu alguns conselhos sobre que tipo de mensagens esperar de diferentes níveis de log que podem ser úteis junto com a resposta de Kurtis:

• Detalhada - Mostra todas as mensagens de log (o padrão).
• Depuração - mostra mensagens de log de depuração que são úteis apenas durante o desenvolvimento, bem como os níveis de mensagem mais baixos nesta lista.
• Info - Mostra as mensagens de log esperadas para uso regular, bem como os níveis de mensagens mais baixos nesta lista.
• Avisar - Mostra possíveis problemas que ainda não são erros, bem como os níveis de mensagem mais baixos nesta lista.
• Erro - mostra os problemas que causaram erros, bem como o nível de mensagem mais baixo nesta lista.
• Afirmar - mostre os problemas que o desenvolvedor espera que nunca aconteçam.