Dlaczego istnieje poziom TRACE i kiedy powinienem go używać zamiast DEBUGI?

W Log4J, Slf4J i kilku innych strukturach rejestrowania w Javie masz dwa poziomy „dewelopera” do rejestrowania:

• ODPLUSKWIĆ
• ŚLAD

Rozumiem, co robi DEBUG, ponieważ wyjaśnienie jest jasne:

Poziom DEBUG określa drobiazgowe zdarzenia informacyjne, które są najbardziej przydatne do debugowania aplikacji.

Ale poziom TRACE nie jest bardzo konkretny w przypadku użycia:

Poziom TRACE określa bardziej szczegółowe wydarzenia informacyjne niż DEBUG

(Źródło: log4J JavaDoc )

To nie mówi mi, jak i kiedy używać TRACE. Co ciekawe, nie jest to poziom ważności zdefiniowany w standardzie syslog . Googling w przypadku różnicy między TRACE a DEBUG wydaje się zwracać „użyj DEBUG, och, i jest też TRACE”. Nie mogłem znaleźć konkretnego przypadku użycia dla poziomu TRACE. Najlepsze, co mogłem znaleźć, to ta stara strona wiki debatująca nad zaletami istnienia poziomu.

To, jako architekt, budzi w mojej głowie wiele flag i pytań. Gdyby młody programista poprosił mnie o dodanie TRACE do mojej architektury, bombardowałbym go pytaniami:

• Jakie są przykłady informacji, które należy rejestrować za pomocą TRACE, a nie DEBUG?
• Jaki konkretny problem rozwiązuję, logując te informacje?
• W tych przykładach, jakie są właściwości rejestrowanych informacji, które wyraźnie odróżniają rejestrowanie na poziomie TRACE niż na poziomie DEBUG?
• Dlaczego te informacje muszą przechodzić przez infrastrukturę dziennika?
  • Jakie są korzyści z utrwalania tych informacji w dziennikach dziennika, a nie tylko ich używania System.out.println?
  • Dlaczego lepiej jest do tego używać dziennika niż debugera?
• Jaki byłby kanoniczny przykład rejestrowania na poziomie TRACE?
  • Jakie konkretne korzyści zostały osiągnięte dzięki logowaniu na poziomie TRACE zamiast DEBUG w tym przykładzie?
  • Dlaczego te zyski są ważne?
  • Na odwrót: jakich problemów uniknąłem logując się do TRACE zamiast DEBUGA?
  • Jak inaczej mogę rozwiązać te problemy? Dlaczego logowanie na poziomie TRACE jest lepsze niż inne rozwiązania?
• Czy w kodzie produkcyjnym należy pozostawić instrukcję dziennika poziomu TRACE? Dlaczego?

Ale biorąc pod uwagę, że jest obecny w większości głównych ram, domyślam się, że jest do czegoś przydatny? Więc ... do czego służy TRACE i co odróżnia ją od DEBUGA?

Jakie są przykłady informacji, które powinny być rejestrowane za pomocą TRACE, a nie DEBUG?

Jeśli mam algorytm, który przechodzi przez kilka kroków, poziom śledzenia wydrukuje informacje o każdym z tych kroków na najlepszym poziomie. Rzeczy takie jak dosłowne dane wejściowe i wyjściowe każdego kroku.

Ogólnie, śledzenie obejmie wszystkie debugowania (podobnie jak debugowanie obejmuje wszystkie ostrzeżenia i błędy).

Jaki konkretny problem rozwiązuję, logując te informacje?

Trzeba debugowanie coś, co wyprowadza sposób zbyt dużo danych do logowania poza określonym build kiedy jesteś kierowanie tej konkretnej rzeczy i nie dbają o błędach lub innych informacji rejestracji (ponieważ ilość informacji śladowej je zasłaniać). W niektórych programach rejestrujących zmienisz określony moduł tylko na poziom śledzenia.

W tych przykładach, jakie są właściwości rejestrowanych informacji, które wyraźnie odróżniają rejestrowanie na poziomie TRACE niż na poziomie DEBUG?

Zasadniczo rejestrowanie na poziomie śledzenia nie może być włączone przez dłuższy czas, ponieważ znacznie obniża wydajność aplikacji i / lub tworzy mnóstwo danych dziennika, które są niezrównoważone z powodu ograniczeń dysku / przepustowości.

Rejestrowanie na poziomie debugowania może zwykle być włączone przez dłuższy czas bez powodowania, że ​​aplikacja nie nadaje się do użytku.

Dlaczego te informacje muszą przechodzić przez infrastrukturę dziennika?

Nie musi. Niektóre frameworki mają osobny tracelogger.

Zwykle kończy się w logach, ponieważ traceloggery i normalne loggery mają podobne potrzeby w zakresie zapisu na dysk / sieć, obsługi błędów, rotacji logów itp.

Dlaczego lepiej jest do tego używać dziennika niż debugera?

Ponieważ debugger może nie być w stanie podłączyć się do komputera, na którym występuje problem. Możesz nie mieć wystarczającej wiedzy, aby wiedzieć, gdzie nawet ustawić punkty przerwania lub przejść przez kod. Może nie być w stanie wiarygodnie odtworzyć błąd w debuggerze, więc użyj dzienników, aby go złapać „jeśli się zdarzy”.

Ale to tylko imiona. Jak każda inna etykieta, to tylko imiona, które ludzie umieszczają na rzeczy i zwykle będą oznaczać różne rzeczy dla różnych ludzi. A sama etykieta jest mniej ważna niż mięsiste bity, do których się odnosi.

Zwróć szczególną uwagę, że slf4j szczególnie odradza używanie trace ( http://slf4j.org/faq.html#trace ):

Krótko mówiąc, chociaż nadal odradzamy korzystanie z poziomu TRACE, ponieważ istnieją alternatywy lub ponieważ w wielu przypadkach żądania rejestrowania poziomu TRACE są marnotrawstwem, biorąc pod uwagę, że ludzie o to prosili, postanowiliśmy pokłonić się popularnemu popytowi.

Osobiście oczekuję , że śledzenie zarejestruje wszystko (np. Nawet takie rzeczy jak „wprowadzono funkcję MyFunc z argumentami A, B, C w czasie Y”). Wadą tego jest to, że jest nie tylko niesamowicie głośny, ale także powoduje problemy z miejscem na dysku; Spodziewałbym się, że takie logowanie zostanie wyłączone podczas normalnych operacji. Zaletą jest to, że daje to poziom informacji podobny do tego, co można uzyskać, przechodząc przez program w przypadkach, w których podłączenie debuggera może być mniej praktyczne.

Ogólnie rzecz biorąc, uważam, że ślad zwykle wymaga więcej wysiłku niż inne podejścia.

Poziomy debugowania są na ogół dowolne i mogą się różnić w zależności od języka, biblioteki i firmy.

Biorąc to pod uwagę, oto jak je widziałem:

ŚLEDZENIE: służy do wyświetlania przebiegu programu na poziomie logiki. Wszedłeś w funkcję? Czy instrukcja „if” wybrała gałąź główną lub „else”? To jest kandydat na ślad. Innymi słowy, rejestrowanie śledzenia jest zwykle używane do określenia „jesteś tutaj”. Jest to przydatne w kontekście innej instrukcji rejestrowania, która może rejestrować błąd lub inne informacje. Rejestrowanie śledzenia może pomóc w zlokalizowaniu w kodzie błędu lub innego zdarzenia zarejestrowanego na innym poziomie.

DEBUG: używany do zrzucania stanu zmiennej, określonych kodów błędów itp. Na przykład: usługa internetowa może zwrócić kod błędu 809214, który może zostać zarejestrowany, gdy aplikacja informuje użytkownika o „nieudanej komunikacji”. Wyobraź sobie, że programista otrzymuje dziennik z systemu użytkownika długo po wystąpieniu błędu i zastanawia się „ dlaczego wystąpił błąd?” dobrze jest logować się na poziomie debugowania. Innym przykładem może być sytuacja, w której błąd występuje nadal w środowisku produkcyjnym, ale jest trudny do odtworzenia, debuguj pewne zmienne lub zdarzenia w kłopotliwym module, aby pomóc programistom poinformować program o stanie programu, gdy wystąpi błąd, aby pomóc w rozwiązywaniu problemów.

Zwykle konfiguruje się aplikację tak, aby logowała się na danym poziomie (lub wyższym). Na przykład śledzenie jest często najniższym poziomem: rejestrowanie na tym poziomie rejestruje wszystko. Poziom debugowania pomija śledzenie, ale obejmuje wysokie poziomy (np. Ostrzeżenia i błędy).

Zaletą segregowania poziomów dziennika jest kontrolowanie zarejestrowanej ilości. W przypadku złożonej aplikacji rejestrowanie śledzenia może potencjalnie rejestrować ogromną ilość danych, z których większość jest bezużyteczna przez większość czasu. Najlepiej jest rejestrować tylko krytyczne informacje (może niektóre informacje startowe, a następnie tylko błędy), chyba że ktoś próbuje ustalić, jak spowodować błąd. Co więcej, jest to na ogół przydatne tylko w środowisku produkcyjnym, w którym debugery i inne narzędzia programistyczne nie są obecne.

Nie ma na to żadnych ograniczeń, żadnych zasad mówiących, że musisz się zalogować w określony sposób. Tylko ogólne konwencje, których mogą przestrzegać niektóre biblioteki lub aplikacje.

Myślę, że doskonałą odpowiedź Telastyna można streścić w mojej krótkiej zasadzie:

• DEBUG rejestrowanie musi być możliwe do wykorzystania w produkcji (ale zwykle jest normalnie wyłączone)
• TRACE rejestrowanie może być takie, że użycie go w środowisku produkcyjnym (innym niż dla konkretnej / krótkiej sesji) jest niemożliwe

Oto moja ogólna zasada

error   you need        to do something
warn    you might need  to do something
info    you need        to log this in production
debug   you might need  to log this in production
trace   everything that is happening (no performance concerns)

Założeniem tego jest to, że zespół operacyjny będzie

• zawsze ustaw produkcję na informacje na poziomie dziennika
• może mieć ustawioną produkcję na debugowanie na poziomie dziennika
• nigdy nie ustawiać produkcji na śledzenie na poziomie dziennika

Uzbrojeni w to założenie, oto, w jaki sposób, jako programista, możesz używać poziomów dziennika ...

Problem nr 1) zbyt duże spowolnienie wydajności produkcji

debugrozwiązuje nr 1. To Ty, jako programista, dokładasz wszelkich starań, aby zrównoważyć informacje, które mogą być potrzebne w produkcji, bez nadmiernego hałasu spowalniającego maszynę. Mówisz „dobrym pomysłem jest ciągłe rejestrowanie tego w produkcji (jeśli chcesz)”.

Problem nr 2) posiadanie pełnych informacji podczas opracowywania

tracerozwiązuje problem nr 2. Absolutnie nie martwisz się, jak wpłynęłoby to na maszynę produkcyjną, ale potrzebujesz tych informacji już teraz podczas opracowywania kodu. Mówisz: „Nie obiecuję, że dobrym pomysłem jest zawsze rejestrować te informacje w produkcji”.

Oczywiście (jak powiedzieli inni) te rzeczy są arbitralne; więc po prostu upewnij się, że Twój zespół programistów (i zespół operacyjny / monitorujący - ponieważ są również użytkownikami Twojego logowania) zgadza się na coś.

Jaki byłby kanoniczny przykład rejestrowania na poziomie TRACE?

WEJŚCIA / WYJŚCIA dzienniki z metody. Te dzienniki pomagają śledzić przebieg programu i są zwykle bardzo przydatne, gdy:

1. Program nagle się zawiesza - dokładnie wiesz, w której funkcji się zawiesił, patrząc na ostatni wiersz dziennika

2. Niektóre nieuczciwe funkcje po cichu zawodzą, absorbując wyjątek

Gwarantują one osobny poziom ŚLEDZENIA, a nie tylko użycie DEBUGOWANIA, ponieważ włączenie dzienników WEJŚCIA / WYJŚCIA dla każdej metody w bazie kodu wygeneruje ogromną liczbę dodatkowych dzienników, których nieuzasadnione jest zawsze , nawet w kontekście DEBUGI.