Warum gibt es den TRACE-Level und wann sollte ich ihn anstelle von DEBUG verwenden?

In Log4J, Slf4J und einigen anderen Protokollierungsframeworks in Java gibt es zwei Entwicklungsstufen für die Protokollierung:

• DEBUGGEN
• SPUR

Ich verstehe, was DEBUG macht, weil die Erklärung klar ist:

Die DEBUG-Ebene kennzeichnet fein abgestimmte Informationsereignisse, die zum Debuggen einer Anwendung am nützlichsten sind.

Die TRACE-Ebene ist jedoch in Bezug auf den Anwendungsfall nicht sehr spezifisch:

Die TRACE-Ebene kennzeichnet detailliertere Informationsereignisse als die DEBUG-Ebene

(Quelle: das log4J JavaDoc )

Dies sagt mir nicht, wie oder wann ich TRACE verwenden soll. Interessanterweise ist dies kein im Syslog-Standard definierter Schweregrad . Das Googeln nach dem Unterschied zwischen TRACE und DEBUG scheint nur "use DEBUG, oh, und es gibt auch TRACE" zurückzugeben. Ich konnte keinen bestimmten Anwendungsfall für die TRACE-Ebene finden. Das Beste, was ich finden konnte, war diese alte Wiki-Seite , auf der über die Existenz des Levels diskutiert wurde.

Dies wirft als Architekt viele Fahnen und Fragen in meinem Kopf auf. Wenn ein junger Entwickler mich bat, TRACE zu meiner Architektur hinzuzufügen, würde ich ihn mit Fragen bombardieren:

• Welche Beispiele für Informationen sollten mit TRACE und nicht mit DEBUG protokolliert werden?
• Welches spezifische Problem löse ich, indem ich diese Informationen aufzeichne?
• Welche Eigenschaften der protokollierten Informationen unterscheiden in diesen Beispielen eindeutig zwischen der Protokollierung auf TRACE-Ebene und der DEBUG-Ebene?
• Warum müssen diese Informationen die Protokollinfrastruktur durchlaufen?
  • Welche Vorteile bietet es, diese Informationen in einem Protokoll zu speichern, anstatt sie nur zu verwenden System.out.println?
  • Warum ist es besser, dafür ein Protokoll zu verwenden, als einen Debugger?
• Was wäre ein kanonisches Beispiel für die Protokollierung auf TRACE-Ebene?
  • Was sind die spezifischen Vorteile, die durch die Protokollierung auf TRACE-Ebene anstelle von DEBUG im Beispiel erzielt wurden?
  • Warum sind diese Gewinne wichtig?
  • Umgekehrt: Welche Probleme habe ich vermieden, indem ich es bei TRACE anstelle von DEBUG protokolliert habe?
  • Wie könnte ich diese Probleme sonst lösen? Warum ist die Protokollierung auf TRACE-Ebene besser als bei diesen anderen Lösungen?
• Soll die Protokollanweisung auf TRACE-Ebene im Produktionscode belassen werden? Warum?

Aber da es in den meisten wichtigen Rahmenbedingungen vorhanden ist, schätze ich, dass es für etwas nützlich ist? Also ... wofür ist TRACE und was unterscheidet es von DEBUG?

Was sind Beispiele für Informationen, die mit TRACE und nicht mit DEBUG protokolliert werden sollen?

Wenn ich einen Algorithmus habe, der eine Reihe von Schritten durchläuft, gibt die Trace-Ebene Informationen zu jedem dieser Schritte auf der besten Ebene aus. Dinge wie die wörtlichen Ein- und Ausgänge jedes Schritts.

Im Allgemeinen enthält der Trace alle Debugs (genau wie das Debug alle Warnungen und Fehler enthält).

Welches spezifische Problem löse ich, indem ich diese Informationen aufzeichne?

Sie müssen etwas debuggen, das viel zu viele Daten ausgibt , um sie außerhalb eines bestimmten Builds zu protokollieren, wenn Sie auf dieses bestimmte Objekt abzielen, und sich nicht um Fehler oder andere Protokollinformationen kümmern (da das Volumen der Trace-Informationen diese verdeckt). In einigen Loggern schalten Sie ein bestimmtes Modul nur auf die Trace-Ebene hoch.

Welche Eigenschaften der protokollierten Informationen unterscheiden in diesen Beispielen eindeutig zwischen der Protokollierung auf TRACE-Ebene und der DEBUG-Ebene?

Im Allgemeinen kann die Protokollierung auf Ablaufverfolgungsebene nicht für einen längeren Zeitraum aktiviert werden, da dadurch die Leistung der Anwendung erheblich beeinträchtigt wird und / oder eine Fülle von Protokolldaten erstellt wird, die aufgrund von Festplatten- / Bandbreitenbeschränkungen nicht nachhaltig sind.

Die Protokollierung auf Debug-Ebene kann normalerweise für einen längeren Zeitraum aktiviert sein, ohne dass die App unbrauchbar wird.

Warum müssen diese Informationen die Protokollinfrastruktur durchlaufen?

Muss es nicht. Einige Frameworks haben einen separaten Tracelogger.

Normalerweise landet es in den Protokollen, da Tracelogger und normale Logger ähnliche Anforderungen in Bezug auf das Schreiben auf Festplatte / Netzwerk, Fehlerbehandlung, Protokollrotation usw. haben.

Warum ist es besser, dafür ein Protokoll zu verwenden, als einen Debugger?

Weil der Debugger möglicherweise keine Verbindung zum Problemcomputer herstellen kann. Möglicherweise wissen Sie nicht genug, um zu wissen, wo Sie Haltepunkte setzen oder den Code schrittweise durcharbeiten können. Möglicherweise können Sie den Fehler in einem Debugger nicht zuverlässig reproduzieren. Verwenden Sie daher die Protokolle, um ihn abzufangen, "wenn er auftritt".

Aber es sind nur Namen. Wie bei jedem anderen Label handelt es sich lediglich um Namen, die von Personen verwendet werden, und die für unterschiedliche Personen normalerweise unterschiedliche Bedeutungen haben. Und das Etikett selbst ist weniger wichtig als die fleischigen Teile, auf die sich das Etikett bezieht.

Beachten Sie insbesondere, dass slf4j ausdrücklich von der Verwendung von trace abrät ( http://slf4j.org/faq.html#trace ):

Kurz gesagt, obwohl wir immer noch davon abraten, die TRACE-Stufe zu verwenden, weil es Alternativen gibt oder weil Protokollanforderungen der TRACE-Stufe in vielen Fällen verschwenderisch sind, haben wir uns entschlossen, der Nachfrage der Bevölkerung zu beugen.

Persönlich würde ich erwarten, dass der Trace alles protokolliert (z. B. auch Dinge wie "Eingegebene Funktion MyFunc mit Argumenten A, B, C zum Zeitpunkt Y"). Der Nachteil dabei ist, dass dies nicht nur unglaublich laut ist, sondern auch Speicherplatzprobleme verursacht. Ich würde erwarten, dass diese Protokollierung während des normalen Betriebs deaktiviert wird. Der Vorteil ist, dass Sie auf diese Weise ähnliche Informationen erhalten wie beim Durchlaufen Ihres Programms, wenn das Anhängen eines Debuggers möglicherweise weniger praktisch ist.

Im Allgemeinen stelle ich fest, dass die Nachverfolgung in der Regel aufwändiger ist als andere Ansätze.

Debug-Levels sind im Allgemeinen völlig willkürlich und können zwischen Sprachen, Bibliotheken und Unternehmen variieren.

Davon abgesehen habe ich hier gesehen, wie sie benutzt wurden:

TRACE: Dient zum Anzeigen des Programmflusses auf Logikebene. Eine Funktion eingegeben? Hat eine "if" -Anweisung den Haupt- oder "else" -Zweig ausgewählt? Das ist ein Kandidat für die Spur. Mit anderen Worten, die Ablaufverfolgungsprotokollierung wird im Allgemeinen verwendet, um anzugeben, dass Sie hier sind. Dies ist nützlich im Zusammenhang mit anderen Protokollierungsanweisungen, die möglicherweise einen Fehler oder andere Informationen protokollieren. Die Ablaufverfolgungsprotokollierung kann dabei helfen, die Position des Fehlers oder eines anderen Ereignisses, das auf einer anderen Ebene protokolliert wurde, im Code genau zu bestimmen.

DEBUG: Dient zum Speichern des Variablenstatus, bestimmter Fehlercodes usw. Beispiel: Ein Webdienst gibt möglicherweise den Fehlercode 809214 zurück, der protokolliert werden kann, während die Anwendung dem Benutzer mitteilt, dass die Kommunikation fehlgeschlagen ist. Stellen Sie sich ein Entwickler ein Protokoll aus dem System des Benutzers empfangen , lange nachdem der Fehler aufgetreten ist und sich fragen , „ warum hat der Fehler auftreten?“ Das ist eine gute Sache, um sich auf der Debug-Ebene anzumelden. Ein weiteres Beispiel könnte sein, dass ein Fehler weiterhin in der Produktion auftritt, aber nur schwer reproduzierbar ist. Debuggen Sie bestimmte Variablen oder Ereignisse im problematischen Modul, um den Entwicklern den Programmstatus mitzuteilen, wenn der Fehler auftritt, und helfen Sie bei der Fehlerbehebung.

Normalerweise würde man die Anwendung so konfigurieren, dass sie auf einer bestimmten Ebene (oder höher) protokolliert. Beispielsweise ist Trace häufig die unterste Ebene: Bei der Protokollierung auf dieser Ebene wird alles protokolliert. Auf der Debug-Ebene wird die Ablaufverfolgung ausgelassen, es werden jedoch hohe Ebenen (z. B. Warnungen und Fehler) eingeschlossen.

Der Vorteil der Trennung der Protokollebenen besteht in der Steuerung der protokollierten Menge. Bei einer komplexen Anwendung kann die Ablaufverfolgungsprotokollierung möglicherweise eine enorme Datenmenge protokollieren, von denen ein Großteil die meiste Zeit unbrauchbar ist. Es ist am besten, nur kritische Informationen zu protokollieren (möglicherweise einige Startinformationen, dann nur Fehler), es sei denn, man versucht zu ermitteln, wie ein Fehler verursacht werden kann. Darüber hinaus ist dies in der Regel nur in einer Produktionsumgebung sinnvoll, in der Debugger und andere Entwicklungstools nicht vorhanden sind.

Es gibt keine wirklichen Grenzen, keine Regeln, die besagen, dass Sie sich auf eine bestimmte Weise anmelden müssen. Nur allgemeine Konventionen, denen einige Bibliotheken oder Anwendungen möglicherweise folgen oder nicht.

Ich denke, Telastyns ausgezeichnete Antwort lässt sich zu meiner kurzen Faustregel zusammenfassen:

• DEBUG Protokollierung muss in der Lage sein, in der Produktion verwendet zu werden (neigt aber dazu, normal ausgeschaltet zu sein)
• TRACE Die Protokollierung darf so erfolgen, dass eine Verwendung in der Produktion (außer für eine bestimmte / kurze Sitzung) nicht möglich ist

Hier ist meine Faustregel

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)

Die Annahme dahinter ist, dass das ops-Team dies tun wird

• Die Produktion muss immer auf Informationen auf Protokollebene eingestellt sein
• Möglicherweise ist die Produktion auf das Debuggen auf Protokollebene eingestellt
• Die Produktion darf niemals auf Protokollierungsebene eingestellt sein

In Anbetracht dieser Annahme können Sie als Entwickler die Protokollebenen wie folgt verwenden ...

Problem Nr. 1) Verlangsamt die Produktionsleistung nicht zu sehr

debuglöst # 1. Als Entwickler geben Sie Ihr Bestes, um die Informationen auszugleichen, die Sie in der Produktion benötigen, ohne dass Sie zu viel Lärm verursachen und die Maschine verlangsamen. Sie sagen, "es ist eine gute Idee, dies ständig in der Produktion zu protokollieren (wenn Sie möchten)."

Problem Nr. 2) Ausführliche Informationen während der Entwicklung

tracelöst Problem Nr. 2. Sie haben absolut keine Bedenken, welche Auswirkungen dies auf eine Produktionsmaschine haben würde, aber Sie benötigen diese Informationen jetzt, während Sie den Code entwickeln. Sie sagen: "Ich verspreche nicht, dass es eine gute Idee ist, diese Informationen immer in der Produktion zu protokollieren."

Zugegeben (wie andere gesagt haben), diese Dinge sind willkürlich; Stellen Sie also sicher, dass sich Ihr Entwicklungsteam (und das Operations- / Überwachungsteam - da sie auch Benutzer Ihrer Protokollierung sind) auf etwas einigen.

Was wäre ein kanonisches Beispiel für die Protokollierung auf TRACE-Ebene?

ENTRY / EXIT-Protokolle von einer Methode. Diese Protokolle helfen Ihnen, den Programmfluss zu verfolgen und sind in den folgenden Fällen sehr nützlich:

1. Das Programm stürzt abrupt ab - Sie wissen genau, in welcher Funktion es abgestürzt ist, indem Sie sich die letzte Zeile des Protokolls ansehen

2. Einige Rogue-Funktionen schlagen unbemerkt fehl, indem sie eine Ausnahme absorbieren

Sie erfordern eine separate TRACE-Ebene, anstatt nur DEBUG zu verwenden, da das Aktivieren von ENTRY / EXIT-Protokollen für jede Methode in Ihrer Codebasis eine enorme Menge zusätzlicher Protokolle generiert, die nicht immer aktiviert sein können , selbst in einem DEBUG-Kontext.