Android Log.v (), Log.d (), Log.i (), Log.w (), Log.e () - Kiedy z nich korzystać?

Różne LogCatmetody to:

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

Jakie są odpowiednie sytuacje, aby korzystać z każdego rodzaju rejestrowania? Wiem, że być może to tylko trochę semantyka i może to nie ma znaczenia, ale dla LogCatfiltrowania w Android Studio i Eclipse miło byłoby wiedzieć, że używam odpowiednich metod w odpowiednich momentach.

Przejdźmy w odwrotnej kolejności:

• Log.e : Dzieje się tak, gdy zdarzają się złe rzeczy. Użyj tego tagu w miejscach takich jak instrukcja catch. Ty wiesz , że błąd wystąpił i dlatego jesteś zalogowaniu błąd.

• Log.w : Użyj tego, gdy podejrzewasz, że dzieje się coś podejrzanego. Możesz nie być w pełni w trybie błędu, ale być może wyzdrowiałeś po nieoczekiwanym zachowaniu. Zasadniczo użyj tego do rejestrowania rzeczy, których się nie spodziewałeś, ale niekoniecznie jest to błąd. Coś w stylu „hej, to się zdarzyło i to dziwne , powinniśmy się temu przyjrzeć”.

• Log.i : Użyj tego, aby opublikować przydatne informacje w dzienniku. Na przykład: że udało Ci się połączyć z serwerem. Zasadniczo używaj go do zgłaszania sukcesów.

• Log.d : Użyj tego docelów debugowania . Jeśli chcesz wydrukować kilka wiadomości, aby móc zarejestrować dokładny przebieg programu, użyj tego. Jeśli chcesz prowadzić dziennik wartości zmiennych, użyj tego.

• Log.v : Użyj tego, gdy chcesz całkowicie oszaleć przy logowaniu. Jeśli z jakiegoś powodu zdecydowałeś się rejestrować każdą drobiazg w określonej części aplikacji, użyj tagu Log.v.

A jako bonus ...

• Log.wtf : Użyj tego, gdy coś pójdzie absolutnie, okropnie, do cholery, źle. Znasz te bloki catch, w którychwyłapujeszbłędy, których nigdy nie powinieneś dostać ... tak, jeśli chcesz je zalogować, użyj Log.wtf

Różne metody wskazują na priorytet. Jak je wymieniłeś, przechodzą od najmniej do najważniejszych. Myślę, że sposób ich mapowania na dzienniki debugowania w kodzie zależy od komponentu lub aplikacji, nad którymi pracujesz, a także od tego, jak system Android traktuje je w różnych wersjach kompilacji (eng, userdebug i user). Wykonałem sporo pracy w natywnych demonach Androida i tak właśnie to robię. Może nie dotyczyć bezpośrednio Twojej aplikacji, ale może mieć pewne wspólne podłoże. Jeśli moje wyjaśnienie brzmi niejasno, to dlatego, że niektóre z nich są bardziej sztuką niż nauką. Moją podstawową zasadą jest być tak wydajnym, jak to możliwe, zapewnić, że możesz rozsądnie debugować swój komponent bez utraty wydajności systemu, a także zawsze sprawdzać błędy i rejestrować je.

V - Wydruki stanu w różnych odstępach czasu lub po wystąpieniu zdarzeń przetwarzanych przez mój komponent. Możliwe również bardzo szczegółowe wydruki ładunków wiadomości / zdarzeń, które mój komponent odbiera lub wysyła.

D - Szczegóły dotyczące drobnych zdarzeń, które występują w moim komponencie, a także ładunków wiadomości / zdarzeń, które mój komponent odbiera lub wysyła.

I - Nagłówek wszelkich wiadomości / zdarzeń, które mój komponent otrzymuje lub wysyła, a także wszelkich ważnych elementów ładunku, które są krytyczne dla działania mojego komponentu.

W - Wszystko, co się dzieje, jest niezwykłe lub podejrzane, ale niekoniecznie błąd.

E - Błędy, co oznacza rzeczy, które nie powinny się zdarzyć, gdy rzeczy działają tak, jak powinny.

Największym błędem, jaki popełniam, jest to, że nadużywają rzeczy takich jak V, D i I, ale nigdy nie używają W lub E. Jeśli błąd z definicji nie powinien się zdarzyć lub powinien zdarzyć się bardzo rzadko, to jest to wyjątkowo taniej, aby zalogować wiadomość, gdy się pojawi. Z drugiej strony, jeśli za każdym razem, gdy ktoś naciśnie klawisz, wykonasz Log.i (), nadużywasz udostępnionego zasobu rejestrowania. Oczywiście, kieruj się zdrowym rozsądkiem i zachowaj ostrożność przy logach błędów dotyczących rzeczy poza twoją kontrolą (takich jak błędy sieciowe) lub tych zawartych w ciasnych pętlach.

Może źle

Log.i("I am here");

Dobrze

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

Mając to wszystko na uwadze, im bliżej kodu będzie „gotowy do produkcji”, tym bardziej możesz ograniczyć podstawowy poziom rejestrowania kodu (potrzebujesz V w wersji alfa, D w wersji beta, I w produkcji, a nawet W w produkcji ). Powinieneś przejrzeć kilka prostych przypadków użycia i przejrzeć dzienniki, aby upewnić się, że nadal możesz w większości zrozumieć, co się dzieje, stosując bardziej restrykcyjne filtrowanie. Jeśli korzystasz z poniższego filtra, nadal powinieneś być w stanie powiedzieć, co robi Twoja aplikacja, ale może nie uzyskać wszystkich szczegółów.

logcat -v threadtime MyApp:I *:S

Kod źródłowy zawiera kilka podstawowych wskazówek:

Kolejność pod względem szczegółowości, od najmniej do większości, to BŁĄD, OSTRZEŻENIE, INFORMACJE, DEBUGA, VERBOSE. Verbose nigdy nie powinien być kompilowany do aplikacji inaczej niż podczas programowania. Dzienniki debugowania są kompilowane, ale usuwane w czasie wykonywania. Dzienniki błędów, ostrzeżeń i informacji są zawsze przechowywane.

Aby uzyskać więcej informacji, odpowiedź Kurtisa jest martwa. Chciałbym tylko dodać: Nie rejestruj żadnych danych umożliwiających identyfikację lub prywatnych informacji na poziomie INFOlub powyżej ( WARN/ ERROR). W przeciwnym razie raporty o błędach lub cokolwiek innego, co obejmuje rejestrowanie, może zostać zanieczyszczone.

Możesz użyć LOG, takich jak:

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)

przykładowy kod:

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

Myślę, że celem tych różnych rodzajów rejestrowania jest to, że chcesz, aby aplikacja w zasadzie samodzielnie filtrowała własne dzienniki. Tak więc Verbose może rejestrować absolutnie wszystko, co ważne w Twojej aplikacji, wtedy poziom debugowania rejestruje podzbiór dzienników pełnych, a następnie poziom informacji rejestruje podzbiór dzienników debugowania. Kiedy przejdziesz do Dzienników błędów, po prostu chcesz zarejestrować wszelkiego rodzaju błędy, które mogły wystąpić. Istnieje również poziom debugowania o nazwie Fatal, gdy coś naprawdę uderza fanów w Twojej aplikacji.

Ogólnie rzecz biorąc, masz rację, jest to w zasadzie arbitralne i od Ciebie zależy, czy dziennik debugowania będzie porównywany z informacyjnym, z błędem itp. Itd.

Mimo że na to pytanie zostało już udzielone, wydaje mi się, że brakuje odpowiedzi na udzielone odpowiedzi.

Dlatego przyniosę tutaj to, co napisałem w blogu „Android Log Levels”

Gadatliwy

Jest najniższym poziomem rejestrowania. Jeśli chcesz zwariować na punkcie logowania, idź z tym poziomem. Nigdy nie rozumiałem, kiedy używać Verbose, a kiedy Debugować. Różnica brzmiała dla mnie bardzo arbitralnie. W końcu zrozumiałem, kiedy wskazano mi kod źródłowy Androida¹ „Verbose nigdy nie powinien być kompilowany w aplikację inaczej niż podczas programowania”. Teraz jest dla mnie jasne, że za każdym razem, gdy się rozwijasz i chcesz dodać usuwalne dzienniki, które pomogą ci podczas programowania, warto mieć poziom szczegółowości, który pomoże Ci usunąć wszystkie te dzienniki, zanim przejdziesz do produkcji.

Odpluskwić

Jest do celów debugowania. To najniższy poziom, jaki powinien być w produkcji. Informacje, które są tutaj, mają pomóc w rozwoju. Najczęściej wyłączasz ten dziennik podczas produkcji, aby mniej informacji było wysyłanych i włączasz ten dziennik tylko w przypadku problemów. Lubię się logować, debugować wszystkie informacje, które aplikacja wysyła / odbiera z serwera (uważaj, aby nie rejestrować haseł !!!). Jest to bardzo pomocne, aby zrozumieć, czy błąd leży na serwerze lub w aplikacji. Rejestruję również dzienniki wchodzenia i wychodzenia z ważnych funkcji.

Informacje

Dla komunikatów informacyjnych, które podkreślają postęp aplikacji. Na przykład po zakończeniu inicjalizacji aplikacji. Dodaj informacje, gdy użytkownik porusza się między działaniami i fragmentami. Rejestruj każde wywołanie interfejsu API, ale niewiele informacji, takich jak adres URL, status i czas odpowiedzi.

Ostrzeżenie

Gdy występuje potencjalnie szkodliwa sytuacja.

Ten dziennik jest według mnie trudnym poziomem. Kiedy masz potencjalnie szkodliwą sytuację? Zasadniczo lub że jest w porządku lub że jest to błąd. Osobiście nie używam tego poziomu zbyt często. Przykładami tego, kiedy go używam, są zwykle sytuacje, w których dzieje się kilka razy. Na przykład użytkownik ma nieprawidłowe hasło więcej niż 3 razy. Może to wynikać z tego, że 3 razy wprowadził nieprawidłowe hasło, a także z powodu problemu z postacią, która nie jest akceptowana w naszym systemie. To samo dotyczy problemów z połączeniem sieciowym.

Błąd

Zdarzenia o błędach. Aplikacja może nadal działać po wystąpieniu błędu. Może to być na przykład kiedy otrzymuję wskaźnik zerowy, w którym nie powinienem go mieć. Wystąpił błąd podczas analizowania odpowiedzi serwera. Wystąpił błąd z serwera.

WTF (What a Terrible Failure)

Śmiertelny jest w przypadku poważnych błędów, które doprowadzą do wyjścia aplikacji. W Androidzie fatalny jest w rzeczywistości poziom błędu, różnica polega na tym, że dodaje także pełny stos.

Witryna Android Studio niedawno (jak sądzę) dostarczyła porady, jakich wiadomości należy się spodziewać na różnych poziomach dziennika, które mogą być przydatne wraz z odpowiedzią Kurtisa:

• Pełne - Pokaż wszystkie komunikaty dziennika (domyślne).
• Debugowanie - Pokaż komunikaty dziennika debugowania przydatne tylko podczas programowania, a także poziomy komunikatów niższe na tej liście.
• Informacje - Pokaż oczekiwane komunikaty dziennika do regularnego użytku, a także poziomy wiadomości niższe na tej liście.
• Ostrzegaj - pokaż możliwe problemy, które nie są jeszcze błędami, a także niższe poziomy wiadomości na tej liście.
• Błąd - pokaż problemy, które spowodowały błędy, a także niższy poziom wiadomości na tej liście.
• Potwierdź - pokaż problemy, których spodziewa się programista, nigdy nie powinny się zdarzyć.