So implementieren Sie die Protokollierung in einer Node.js-Anwendung mit Pino-Logger

Eine effektive Protokollierung ist für die Anwendungsentwicklung von entscheidender Bedeutung. Es bietet Einblicke in das Anwendungsverhalten und vereinfacht das Debuggen. Dieses Tutorial zeigt, wie die Protokollierung in einer Node.js -Anwendung mit dem Pino Logger implementiert wird, einer beliebten Wahl, die für seine Leistung und Flexibilität bekannt ist.

Pino ermöglicht eine umfassende Protokollierung, einschließlich detaillierter Informationen zum Anwendungsfluss und der Möglichkeit, Protokolle in getrennten Dateien zu speichern. Die umfangreiche Github -Community unterstreicht die Zuverlässigkeit weiter.

Dieser Leitfaden umfasst:

• Konfigurieren von Protokollierungsstufen.
• Anpassen der Protokollausgabe für eine verbesserte Lesbarkeit im Terminal, einschließlich Optionen für die Aufnahme von JSON -Antwort.
• Speichern von Protokollen in einer dedizierten Datei.

Am Ende können Sie eine robuste Protokollierung in Ihren Node.js -Anwendungen mit Best Practices und Pino implementieren.

Voraussetzungen

Stellen Sie vor dem Fortfahren sicher, dass Sie:

• Erfahrung mit Express.js für die serverseitige Entwicklung.
• Vertrautheit mit dem Aufbau von REST -APIs ohne Authentifizierung.
• Kenntnisse mit Befehlszeilen-Tools oder integrierten Terminals in Code-Editoren.

Die Verwendung eines Tools wie Postman für API -Endpunkt -Tests wird empfohlen.

Schritt 1: Projekteinrichtung

Dieser Schritt beinhaltet die Erstellung einer grundlegenden Node.js -CRUD -Anwendung mit Express.js und Mongoose. Dieser Ansatz stellt sicher, dass die Protokollierungsfunktionalität in einem realistischen Anwendungskontext implementiert wird.

Informationen zum CRUD -Anwendungsaufbau finden Sie in einem Tutorial zum Durchführen von CRUD -Operationen mit Mongoose und MongoDB Atlas. Sobald Sie fertig sind, haben Sie eine Node.js -Anwendung mit Erstellen, Lesen, Aktualisieren und Löschen von Routen.

Installieren Sie nodemon für automatische Server -Neustart bei Codeänderungen:

 NPM install -g -Force Nodemon

Das -g -Flag installiert weltweit und --force behandelt potenzielle Konflikte.

Schritt 2: Pino installieren

Installieren Sie die erforderlichen Abhängigkeiten: Pino, Express-Pino-Logger und Pino-Pretty:

 NPM Pino Express-Pino-Logger Pino-Pretty installieren

Schritt 3: Erstellen des Logger -Dienstes

Erstellen Sie einen Pino -Logger -Dienst mit verschiedenen Protokollebenen (Warnung, Fehler, Info usw.). Dieser Dienst wird mit Node.js Middleware in Ihre Anwendung integriert.

Erstellen Sie ein services -Verzeichnis:

 Mkdir Services

Erstellen Sie loggerService.js in services mit dem folgenden Code:

 const pino = require ('pino');
module.exports = pino ({PrettyPrint: true});

Dies erstellt einen grundlegenden Logger mit ziemlich gedruckter Ausgabe. Spätere Schritte werden weitere Konfiguration abdecken.

Importieren Sie als Nächstes in Ihrer server.js Datei den Logger-Dienst und express-pino-logger :

 const expresspinologger = required ('express-pino-logger');
const logger = fordert ('./ dienste/loggerservice');

Konfigurieren Sie express-pino-logger mit Ihrem Logger-Dienst:

 // ...
const loggermiddleware = expressPinologger ({{
  Logger: Logger,
  Autologging: wahr,
});

app.use (loggermiddleware);
// ...

autoLogging: true enthält die JSON -Antwort in Protokollen.

Importieren und verwenden Sie den Logger in Ihrem Routenhandler (z. B. foodRoutes.js ):

 const logger = fordert ('../ dienste/loggerservice');

// ...
app.get ("/food", async (request, response) => {
  logger.info ('Route zugreifen');
  // ...
});
// ...

Starten Sie Ihren Server neu ( nodemon server.js ) und testen Sie den API -Endpunkt. Die Protokollausgabe wird in Ihrem Terminal angezeigt.

Schritt 4: Protokolle konfigurieren

Dieser Schritt konzentriert sich auf das Anpassen des Logger -Dienstes und die Verbesserung der Lesbarkeit des Protokolls.

Benutzerdefinierte Protokollebenen

Definieren Sie benutzerdefinierte Protokollpegel in loggerService.js :

 // ...
const steges = {
  http: 10,
  DEBUG: 20,
  Info: 30,
  WARN: 40,
  Fehler: 50,
  tödlich: 60,
};
// ...

Aktualisieren Sie die pino -Konfiguration in loggerService.js :

 module.exports = pino ({{{
  PrettyPrint: Richtig,
  CustomLevels: Levels,
  UseOnlycustomlevels: wahr,
  Ebene: 'Http',
});

Test mit benutzerdefinierten Ebenen (z. B. logger.http(...) ). Setzen Sie autoLogging: false in server.js Wenn die JSON -Antwort unnötig ist.

Hübscher Druck

Verbesserung der Protokollformatierung in loggerService.js :

 module.exports = pino ({{{
  CustomLevels: Levels,
  UseOnlycustomlevels: wahr,
  Ebene: 'Http',
  PrettyPrint: {
    folellieren: wahr,
    Levelfirst: wahr,
    TranslateTime: 'yyyy-dd-mm, h: mm: ss tt',
  },
});

Testen Sie erneut, um die verbesserte Protokollausgabe zu sehen.

Schritt 5: Speichern Sie Protokolle in einer Datei

Um Protokolle in eine Datei zu schreiben, ändern Sie die pino -Konfiguration in loggerService.js :

 module.exports = pino ({{{
  CustomLevels: Levels,
  UseOnlycustomlevels: wahr,
  Ebene: 'Http',
  PrettyPrint: {
    folellieren: wahr,
    Levelfirst: wahr,
    TranslateTime: 'yyyy-dd-mm, h: mm: ss tt',
  },
}, pino.destination (`$ {__ Dirname}/logger.log`));

Testen Sie Ihre API; Protokolle werden nun im services an logger.log geschrieben.

Abschluss

Dieses Tutorial bot einen umfassenden Leitfaden zur Implementierung der Pino -Protokollierung in Node.js -Anwendungen. Denken Sie an Best Practices: Kontextinformationen, klarer Zweck und lesbare Formatierung sind der Schlüssel zu einer effektiven Protokollierung. Entdecken Sie die offizielle Pino -Dokumentation für erweiterte Konfigurationsoptionen.

Das obige ist der detaillierte Inhalt vonSo implementieren Sie die Protokollierung in einer Node.js-Anwendung mit Pino-Logger. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!