Haben Sie Schwierigkeiten beim Aufspüren von Fehlern in Ihrem Programmcode? Suchen Sie nach Möglichkeiten, die Protokollierung zu nutzen, um das Debuggen zu vereinfachen? Dann lesen Sie weiter, um mehr darüber zu erfahren.
Die Softwareentwicklung umfasst mehrere Phasen: die Erfassung der Anforderungen, die Analyse, die Programmierung, das Testen und die Wartung. Von all diesen Phasen ist die Programmier- bzw. Entwicklungsphase oft die zeitaufwendigste und anspruchsvollste. Softwareentwickler stoßen dabei auf Syntaxfehler, Logikfehler und Laufzeitfehler. Syntaxfehler werden bereits während des Kompilierens erkannt, da der Code nicht den Regeln der jeweiligen Programmiersprache entspricht.
Logikfehler und Laufzeitfehler hingegen sind für die integrierte Entwicklungsumgebung (IDE) nicht erkennbar und erweisen sich oft als schwer zu finden und zu beheben. Die Fehlerbehebung ist ein komplexer und zeitraubender Vorgang, der viel Debugging erfordert.
Debugging ist der Prozess, mit dem man versucht zu verstehen, warum der geschriebene Code nicht wie gewünscht funktioniert. Es ist einfacher, das Problem zu lösen, wenn die Fehlerursache und die genauen Codezeilen, in denen der Fehler auftritt, bekannt sind. Daher ist die Protokollierung ein sehr wertvolles Werkzeug für das Debuggen von Code.
Was genau ist Protokollierung?
Unter Protokollierung versteht man eine Technik, bei der während der Programmausführung Meldungen erfasst werden. Dabei sollten nur die Meldungen protokolliert werden, die beim Debuggen hilfreich sein könnten. Es ist daher entscheidend zu wissen, wann Protokollanweisungen zum Code hinzugefügt werden müssen. Ebenso wichtig ist es, zwischen verschiedenen Protokollanweisungen zu unterscheiden. Es gibt verschiedene Protokollstufen, wie z.B. Info, Warnung, Fehler, Debug und Ausführlich. Fehler- und Warnmeldungen werden für die Ausnahmebehandlung verwendet.
Von Funktionen zurückgegebene Daten, Ergebnisse von Array-Manipulationen, von APIs abgerufene Daten usw. sind Beispiele für Daten, die mit Info-Anweisungen protokolliert werden können. Die Debug- und ausführlichen Protokolle werden verwendet, um eine detaillierte Fehlerbeschreibung zu liefern.
Das Debug-Protokoll gibt Auskunft über den Stack-Trace, Ein- und Ausgabeparameter usw. „Ausführlich“ ist nicht so detailliert wie das „Debug“-Protokoll, listet aber alle aufgetretenen Ereignisse auf. Protokolle werden in die Konsole, in Dateien oder den Ausgabestream geschrieben. Für eine strukturierte und formatierte Protokollierung können Protokollverwaltungstools eingesetzt werden.
Protokollierung in Node.js
Node.js ist eine JavaScript-Laufzeitumgebung. Node.js-Anwendungen sind asynchron und nicht blockierend und werden oft in datenintensiven Echtzeitsystemen verwendet. Der beste Weg, mehr über Node.js zu lernen, ist das Durcharbeiten der Tutorials und der dazugehörigen Dokumentation. Die Protokollierung ist notwendig, um die Leistung zu verbessern, Fehler zu beheben und Fehler zu verfolgen. In Node.js kann die Protokollierung mit der eingebauten Funktion `console.log` erfolgen. Darüber hinaus gibt es zahlreiche Pakete für die Debug-Funktion, die ebenfalls effektiv genutzt werden können.
Middleware wird verwendet, um Anfragen und Antworten zu verwalten. Middleware kann eine Anwendung oder ein beliebiges JavaScript-Framework sein. Die Protokollierung in Middleware kann über Anwendungen und Router erfolgen. Jeder Node.js-Logger muss den Befehl `npm` oder `yarn install` verwenden, um die Logger zu installieren.
Npm steht für „Node Package Manager“, und YARN steht für „Yet Another Resource Negotiator“. Yarn wird jedoch gegenüber npm bevorzugt, da es schneller ist und Pakete parallel installiert.
Hier sind einige der besten Node.js-Logger:
Pino
Pino ist eine Bibliothek, die sich als einer der besten Logger für Node.js-Anwendungen etabliert hat. Sie ist Open Source, extrem schnell und protokolliert die Anweisungen in einem leicht lesbaren JSON-Format. Einige der Pino-Protokollebenen sind Debug-, Warn-, Fehler- und Infomeldungen. Eine Pino-Loggerinstanz kann in das Projekt importiert und die `console.log`-Anweisungen durch `logger.info`-Anweisungen ersetzt werden.
Verwenden Sie den folgenden Befehl, um Pino zu installieren:
$ npm install pino
Die erzeugten Protokolle sind ausführlich und im JSON-Format, wobei die Zeilennummer des Protokolls, der Protokolltyp, die Zeit der Protokollierung usw. hervorgehoben werden. Pino verursacht nur einen minimalen Overhead beim Protokollieren in einer Anwendung und ist äußerst flexibel bei der Verarbeitung von Protokollen.
Pino kann in Web-Frameworks wie Hapi, Restify, Express usw. integriert werden. Von Pino erzeugte Protokolle können auch in Dateien gespeichert werden. Es nutzt Worker-Threads für den Betrieb und ist mit TypeScript kompatibel.
Winston
Winston bietet Protokollierungsunterstützung für verschiedene Web-Frameworks mit besonderem Fokus auf Flexibilität und Erweiterbarkeit. Es unterstützt verschiedene Transportarten und kann Protokolle an unterschiedlichen Speicherorten ablegen. Transporte sind die Orte, an denen die Protokollmeldungen gespeichert werden.
Neben einigen integrierten Transporten wie Http, Console, File und Stream unterstützt Winston auch andere Transporte wie CloudWatch und MongoDB. Es protokolliert auf verschiedenen Ebenen und in verschiedenen Formaten. Die Protokollebenen geben den Schweregrad des Problems an.
Die verschiedenen Protokollebenen sind wie folgt:
{
error: 0,
warn: 1,
info: 2,
http: 3,
verbose: 4,
debug: 5,
silly: 6
}
Das Format der Protokollausgabe kann ebenfalls angepasst, gefiltert und kombiniert werden. Protokolle enthalten Informationen über den Zeitstempel, mit einem Protokoll verknüpfte Labels, die seit dem vorherigen Protokoll vergangenen Millisekunden usw.
Winston kümmert sich auch um Ausnahmen und nicht abgefangene Versprechen. Es bietet zusätzliche Funktionen wie die Ablage von Abfragen zur Laufzeit, Streaming-Protokolle usw. Zuerst muss Winston installiert werden. Anschließend wird ein Winston-Konfigurationsobjekt zusammen mit dem Transport für die Protokollspeicherung erstellt. Ein Logger-Objekt wird mit der Funktion `createLogger()` erstellt und die Log-Meldung an dieses Objekt übergeben.
Node-Bunyan
Bunyan wird für die schnelle Protokollierung in Node.js im JSON-Format verwendet. Es bietet auch ein CLI-Tool (Command Line Interface) zum Anzeigen der Protokolle. Es ist leichtgewichtig und unterstützt verschiedene Laufzeitumgebungen wie Node.js, Browserify, WebPack und NW.js. Das JSON-Format der Protokolle wird durch die Pretty-Print-Funktion noch ansprechender gestaltet. Protokolle haben verschiedene Ebenen wie fatal, error, warn, info, debug und trace, denen jeweils ein numerischer Wert zugewiesen ist.
Alle Ebenen oberhalb der für die Instanz festgelegten Ebene werden protokolliert. Ein Bunyan-Stream ist der Ort, an dem die Ausgaben protokolliert werden. Unterkomponenten einer Anwendung können mit der Funktion `log.child()` protokolliert werden. Alle untergeordneten Logger sind an eine bestimmte übergeordnete Anwendung gebunden. Der Stream-Typ kann eine Datei, eine rotierende Datei, Rohdaten usw. sein. Ein Codebeispiel zur Definition eines Streams ist unten dargestellt:
var bunyan = require('bunyan');
var log = bunyan.createLogger({
name: "foo",
streams: [
{
stream: process.stderr,
level: "debug"
},
...
]
});
Bunyan unterstützt auch die DTrace-Protokollierung. Die an der DTrace-Protokollierung beteiligten Prüfpunkte sind `log-trace`, `log-warn`, `log-error`, `log-info`, `log-debug` und `log-fatal`. Bunyan verwendet Serialisierer, um die Protokolle im JSON-Format zu erstellen. Serialisierungsfunktionen werfen keine Ausnahmen aus und sind defensiv programmiert.
Loglevel
Loglevel wird für die Protokollierung in JavaScript-Anwendungen verwendet. Es ist ebenfalls einer der besten Logger für Node.js, da es leicht und einfach zu bedienen ist. Es protokolliert die angegebene Ebene und verwendet eine einzige Datei ohne Abhängigkeiten für die Protokollierung. Die Standardprotokollebene ist „warn“. Die Protokollausgaben sind zusammen mit den Zeilennummern gut formatiert. Einige der Methoden, die für die Protokollierung verwendet werden, sind Trace, Debug, Warn, Error und Info.
Sie sind in jeder Umgebung ausfallsicher. `getLogger()` ist die Methode, die zum Abrufen des Logger-Objekts verwendet wird. Es kann auch mit anderen Plugins kombiniert werden, um seine Funktionen zu erweitern. Einige der Plugins sind `loglevel-plugin-prefix`, `loglevel-plugin-remote`, `ServerSend` und `DEBUG`. Das Plugin zum Hinzufügen von Präfixmeldungen zur Protokollierung ist unten dargestellt:
var originalFactory = log.methodFactory;
log.methodFactory = function (methodName, logLevel, loggerName) {
var rawMethod = originalFactory(methodName, logLevel, loggerName);
return function (message) {
rawMethod("Newsflash: " + message);
};
};
log.setLevel(log.getLevel()); // Be sure to call setLevel method in order to apply plugin
Die Builds werden mit dem Befehl `npm run dist` ausgeführt, und die Tests können mit dem Befehl `npm test` ausgeführt werden. Loglevel unterstützt Webjar-, Bower- und Atmosphere-Pakete. Eine neue Version von Loglevel wird veröffentlicht, sobald neue Funktionen hinzugefügt werden.
Signale
Signale besteht aus 19 Loggern für JavaScript-Anwendungen. Es unterstützt TypeScript und die bereichsbezogene Protokollierung. Es enthält Timer, die helfen, den Zeitstempel, die Daten und den Dateinamen zu protokollieren. Neben den 19 Standardloggern wie `await`, `complete`, `fatal`, `fav`, `info` usw. können benutzerdefinierte Logs erstellt werden.
Benutzerdefinierte Protokolle werden durch Definieren eines JSON-Objekts und Felder mit den Protokolldaten erstellt. Es können auch interaktive Logger erstellt werden. Wenn ein interaktiver Logger auf „true“ gesetzt ist, überschreiben neue Werte interaktiver Logger die alten.
Das Besondere an Signale ist die Möglichkeit, sensible Informationen herauszufiltern. Mehrere Geheimnisse werden in einem Array gespeichert. `addSecrets()` und `clearSecrets()` sind die Funktionen, die zum Hinzufügen und Löschen von Geheimnissen aus dem Array verwendet werden. Boostnote, Docz, Shower, Taskbook und Vant verwenden Signale für die Protokollierung. Die Syntax zum Aufrufen von APIs von Signale lautet wie folgt:
signale.<logger>(message[,message]|messageObj|errorObj)
Die Zahl der Signale-Downloads liegt zum Zeitpunkt der Erstellung dieses Artikels bei über 1 Million.
Tracer
Tracer wird verwendet, um detaillierte Protokollmeldungen zu erstellen. Die Protokollmeldungen umfassen Zeitstempel, Dateinamen, Zeilennummern und Methodennamen. Hilfspakete können installiert werden, um das Format der Ausgabeprotokollierung anzupassen. Die Hilfspakete können mit dem folgenden Befehl installiert werden.
npm install -dev tracer
Tracer unterstützt Datei-, Stream- und MongoDB-Transporte. Es unterstützt Farbkonsolen und Filterbedingungen bei der Protokollierung. Zuerst muss Tracer mit `npm install` installiert werden. Zweitens muss ein Logger-Objekt erstellt und die Art der Konsole ausgewählt werden. Anschließend können über das Objekt die verschiedenen Protokollebenen oder -typen für die weitere Protokollierung angegeben werden.
Benutzerdefinierte Filter können durch die Definition von synchronen Funktionen mit der im Funktionsrumpf vorhandenen Geschäftslogik erstellt werden. Mikrovorlagen wie tinytim können auch für die Systemprotokollierung verwendet werden.
Cabin.js
Cabin wird für die serverseitige und clientseitige Protokollierung von Node.js-Anwendungen verwendet. Es wird dort eingesetzt, wo die Maskierung von sensiblen und kritischen Informationen erforderlich ist. Dazu gehören Kreditkartennummern, BasicAuth-Header, Salts, Passwörter, CSRF-Token und Bankkontonummern. Das folgende Code-Snippet zeigt die Protokollierung mit Cabin.js.
const Cabin = require('cabin');
const cabin = new Cabin();
cabin.info('hello world');
cabin.error(new Error('oops!'));
Es umfasst mehr als 1600 Feldnamen. Es folgt auch dem Prinzip „Bring Your Own Logger“ (BYOL). Dadurch ist es mit verschiedenen anderen Loggern wie Axe, Pino, Bunyan, Winston usw. kompatibel. Es reduziert die Speicherkosten auf Festplatten aufgrund automatischer Stream- und Cabin-Puffer. Es ist plattformübergreifend kompatibel und leicht zu debuggen.
Die serverseitige Protokollierung erfordert die Verwendung von Middleware für das Routing und die automatische Ausgabeprotokollierung. Für die browserseitige Protokollierung sind XHR-Anfragen und -Skripte erforderlich. Cabin verwendet Ax, das Metadaten anzeigt, d.h. Daten über Daten, Stacktraces und andere Fehler. `SHOW_STACK` und `SHOW_META` sind boolesche Variablen, die auf „true“ oder „false“ gesetzt werden, um Stacktraces und Metadaten anzuzeigen oder auszublenden.
Npmlog
Npmlog ist ein grundlegender Logger-Typ, den npm verwendet. Einige der verwendeten Protokollmethoden sind Level, Record, MaxRecordSize, PrefixStyle, Heading und Stream. Es unterstützt auch die farbige Protokollierung. Die verschiedenen Protokollebenen sind albern, ausführlich, info, warn, http und error. Ein Beispielcodeausschnitt für die Verwendung des npm-Protokolls ist unten dargestellt.
var log = require('npmlog')
// additional stuff ---------------------------+
// message ----------+ |
// prefix ----+ | |
// level -+ | | |
// v v v v
log.info('fyi', 'I have a kitty cat: %j', myKittyCat)
Alle Meldungen werden unterdrückt, wenn als Protokollebene „Infinity“ angegeben ist. Wenn als Protokollebene „-Infinity“ angegeben ist, muss die Option zum Anzeigen von Protokollmeldungen aktiviert werden, um die Logs zu sehen.
Zur Protokollierung werden Ereignisse und Nachrichtenobjekte verwendet. Präfixmeldungen werden ausgegeben, wenn Präfixereignisse verwendet werden. Stilobjekte werden zum Formatieren der Protokolle verwendet, z. B. Hinzufügen von Farbe zu Text und Hintergrund, Schriftartstil wie Fett, Kursiv, Unterstrichen usw. Einige npm-Protokollpakete sind brolog, npmlogger, npmdate log usw.
Roarr
Roarr ist ein Logger für Node.js, der keine Initialisierung erfordert und strukturierte Daten erzeugt. Er verfügt über CLI- und Umgebungsvariablen. Er ist browserkompatibel. Er kann in Fastify, Elastic Search usw. integriert werden. Er kann zwischen Anwendungscode und Abhängigkeitscode unterscheiden. Jede Protokollnachricht besteht aus Kontext, Nachricht, Sequenz, Zeit und Version. Zu den verschiedenen Protokollebenen gehören Trace, Debug, Info, Warn, Error und Fatal. Ein Beispielcodeausschnitt, wie die Protokollierung in Roarr erfolgt, lautet wie folgt:
import {
ROARR,
} from 'roarr';
ROARR.write = (message) => {
console.log(JSON.parse(message));
};
Darüber hinaus kann eine Serialisierung von Fehlern durchgeführt werden, was bedeutet, dass die Instanz mit dem Fehler zusammen mit dem Kontext des Objekts protokolliert werden kann. Einige der für Node.js und Roarr spezifischen Umgebungsvariablen sind `ROARR_LOG` und `ROARR_STREAM`. „adopt“ ist eine Funktion, die mit node.js verwendet wird, um die Kontexteigenschaften an verschiedene Ebenen weiterzugeben. Untergeordnete Funktionen können während der Protokollierung auch mit Middleware verwendet werden.
Zusammenfassung
Die Protokollierung ist eine Methode, um verschiedene Aktivitäten und Ereignisse während der Ausführung eines Programms zu verfolgen. Die Protokollierung spielt eine entscheidende Rolle beim Debuggen von Code. Sie hilft auch, die Lesbarkeit des Codes zu verbessern. Node.js ist eine Open-Source-JavaScript-Laufzeitumgebung. Einige der besten Node.js-Logger sind Pino, Winston, Bunyan, Signale, Tracer, Npmlog usw. Jeder Logger-Typ hat seine eigenen Funktionen wie Profilerstellung, Filterung, Streaming und Transport.
Einige Logger unterstützen farbige Konsolen, andere eignen sich für den Umgang mit vertraulichen Informationen. Detaillierte und formatierte Protokolle sind für Entwickler am hilfreichsten, wenn sie versuchen, Fehler in ihrem Code zu beheben. Das JSON-Format wird im Allgemeinen für die Protokollierung bevorzugt, da es Daten in Form von Schlüssel-Wert-Paaren protokolliert, was die Nutzung erleichtert.
Logger können auch in andere Anwendungen integriert werden und sind Multi-Browser-kompatibel. Es ist immer ratsam, sich mit den Anforderungen und Anwendungen zu befassen, die Sie erstellen, bevor Sie den gewünschten Logger-Typ auswählen.
Sie können sich auch informieren, wie Sie Node.js und NPM unter Windows und macOS installieren.