Kæmper du med at fejlfinde din kode? Leder du efter nogle logningsløsninger, der kan gøre fejlfinding lettere? Læs videre for at lære mere.
Softwareudvikling går gennem flere faser: kravindsamling, analyse, kodning, test og vedligeholdelse. Ud af alle disse faser kræver kodnings-/udviklingsfasen meget tid og kræfter. Softwareingeniører håndterer syntaksfejl, logiske fejl og runtime-fejl. Syntaktiske fejl identificeres på kompileringstidspunktet og opstår på grund af, at koden ikke overholder reglerne i et programmeringssprog.
På den anden side kan logiske fejl og køretidsfejl ikke identificeres af det integrerede udviklingsmiljø (IDE) og er ofte svære at fejlfinde og rette. Løsning af fejl er en tidskrævende proces og kræver en del fejlretning.
Debugging er en proces, hvor man forsøger at forstå, hvorfor den skrevne kode ikke fungerer som forventet. Det er nemt at løse problemet, når vi kender fejlen og de nøjagtige linjer i koden, hvor den opstår. Derfor er logning meget nyttig til fejlfinding af kode.
Indholdsfortegnelse
Hvad er logning?
Logning er en teknik, hvor meddelelser fanges under udførelsen af et program. Man skal kun logge de beskeder, som kunne hjælpe dem med at fejlfinde. Så det er ekstremt vigtigt at vide, hvornår man skal tilføje log-sætninger til koden. Det er også lige så vigtigt at skelne mellem log-udsagn. Der er forskellige niveauer i logning, såsom info, advarsel, fejl, fejlfinding og verbose. Fejl- og advarselserklæringer bruges til håndtering af undtagelser.
Data, der returneres fra funktioner, resultater efter array-manipulation, data hentet fra API’er osv., er nogle eksempler på data, der kan logges ved hjælp af info-sætninger. Debug og verbose logs bruges til at give en detaljeret beskrivelse af fejlene.
Fejlretningsloggen giver information om stak-sporing, input-output-parametre osv. “Verbose” er ikke så detaljeret som “debug”-loggen, men giver en liste over alle hændelser, der er opstået. Logfiler skrives ud til konsollen, filerne og outputstrømmen. Logstyringsværktøjer kan bruges til struktureret og formateret logning.
Node.js-logning
Nodejs er et javascript-runtime-miljø. Node.js-applikationer er asynkrone og ikke-blokerende og bruges i dataintensive og realtidssystemer. Den bedste måde at lære mere om Node.js er at gennemgå Node.js tutorials og dens dokumentation. Logning er påkrævet for forbedret ydeevne, fejlfinding og fejlsporing. Log på Node.js kan gøres ved hjælp af den indbyggede funktion console.log. Debug-funktionen er også forbundet med flere pakker og kan bruges effektivt.
Middleware bruges til at administrere anmodninger og svar. Middleware kan være en applikation eller en hvilken som helst anden Javascript-ramme. Log på middleware kan ske gennem applikationer og routere. Enhver Node.js logger skal bruge kommandoen npm eller yarn install for at installere loggerne.
Npm står for “Node Package Manager”, og YARN står for “Yet Another Resource Negotiator”. Garn foretrækkes dog frem for npm, da det er hurtigere og installerer pakker parallelt.
Nogle af de bedste Node.js-loggere er anført nedenfor:
Pino
Pino er et bibliotek, der er en af de bedste loggere til Node.js-applikationer. Det er open source, ekstremt hurtigt og logger udsagn i et letlæseligt JSON-format. Nogle af Pino-logniveauerne er – fejlretnings-, advarsels-, fejl- og infomeddelelser. En Pino logger-instans kan importeres til projektet, og console.log-sætningerne skal erstattes med logger.info-sætninger.
Brug følgende kommando til at installere Pino:
$ npm install pino
De genererede logfiler er udførlige og i JSON-format, der fremhæver loggens linjenummer, typen af log, tidspunktet hvor den blev logget osv. Pino forårsager minimal overhead-logning i en applikation og er ekstremt fleksibel under behandling af logs.
Pino kan integreres med web-frameworks som Hapi, Restify, Express osv. Logs genereret af Pino kan også gemmes i filer. Den bruger Worker-tråde til drift og er kompatibel med TypeScript.
Winston
Winston understøtter logning til forskellige web-frameworks med dets primære fokus på fleksibilitet og udvidelsesmuligheder. Det understøtter flere former for transport og kan gemme logfiler på forskellige filplaceringer. Transporter er steder, hvor logmeddelelserne er gemt.
Sammen med nogle indbyggede transporter som Http, Console, File og Stream, understøtter den andre transporter såsom Cloud Watch og MongoDB. Det logger under forskellige niveauer og formater. Logningsniveauer angiver problemets alvor.
De forskellige logningsniveauer er som vist nedenfor:
{
error: 0,
warn: 1,
info: 2,
http: 3,
verbose: 4,
debug: 5,
silly: 6
}
Logoutputformatet kan også tilpasses, filtreres og kombineres. Logfiler inkluderer oplysninger om tidsstemplet, etiketter forbundet med en log, forløbne millisekunder fra den forrige log osv.
Winston håndterer også undtagelser og ufangne løfter. Det giver yderligere funktioner såsom forespørgsel runtime-arkivering, streaming logs osv. For det første skal man installere Winston. Derefter oprettes et Winston-konfigurationsobjekt sammen med transport til lagring af loggen. Et loggerobjekt oprettes ved hjælp af createLogger()-funktionen, og logmeddelelsen sendes til det.
Node-Bunyan
Bunyan bruges til hurtig logning i node.js i JSON-format. Det giver også et CLI-værktøj (Command Line Interface) til at se logfilerne. Den er let og understøtter forskellige runtime-miljøer som Node.js, Browserify, WebPack og NW.js. Logfilernes JSON-format forskønnes yderligere ved hjælp af den smukke udskrivningsfunktion. Logfiler har forskellige niveauer som fatal, fejl, advarsel, info, fejlretning og sporing; hver er forbundet med en numerisk værdi.
Alle niveauer over det niveau, der er indstillet for instansen, logges. Bunyan stream er et sted, hvor udgangene logges. Underkomponenter af en applikation kan logges ved hjælp af log.child()-funktionen. Alle underordnede loggere er bundet til en specifik overordnet applikation. Strømtypen kan være en fil, roterende fil, rådata osv. Kodeeksemplet til at definere en strøm er vist nedenfor:
var bunyan = require('bunyan');
var log = bunyan.createLogger({
name: "foo",
streams: [
{
stream: process.stderr,
level: "debug"
},
...
]
});
Bunyan understøtter også DTrace-logning. Proberne involveret i DTrace-logning inkluderer log-trace, log-warn, log-error, log-info, log-debug og log-fatal. Bunyan bruger serializers til at producere logfilerne i JSON-format. Serializer-funktioner giver ingen undtagelser og er defensive.
Logniveau
Loglevel bruges til at logge i Javascript-applikationer. Det er også en af Node.js bedste loggere, da den er let og enkel. Det logger det givne niveau og bruger en enkelt fil uden afhængigheder til logning. Standardlogniveauet er “advar”. Logudgangene er godt formateret sammen med linjenumre. Nogle metoder, der bruges til logning, er sporing, debug, advarsel, fejl og info.
De er modstandsdygtige over for fejl i ethvert miljø. getLogger() er den metode, der bruges til at hente loggerobjektet. Det kan også kombineres med andre plugins for at udvide dets funktioner. Nogle af plugins inkluderer loglevel-plugin-prefix, loglevel-plugin-remote, ServerSend og DEBUG. Pluginnet til at tilføje præfiksmeddelelser til logning er vist nedenfor:
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
Bygningerne køres ved hjælp af npm run dist-kommandoen, og testene kan køres ved hjælp af npm-testkommandoen. Logniveau understøtter Webjar-, Bower- og Atmosphere-pakker. En ny version af Loglevel frigives, hver gang nye funktioner tilføjes.
Signale
Signale består af 19 loggere til Javascript-applikationer. Det understøtter TypeScript og scoped logging. Den består af timere, der hjælper med at logge tidsstemplet, data og filnavn. Bortset fra de 19 loggere som await, complete, fatal, fav, info osv., kan man oprette brugerdefinerede logs.
Brugerdefinerede logfiler oprettes ved at definere et JSON-objekt og felter med loggerdataene. Interaktive loggere kan også oprettes. Når en interaktiv logger er indstillet til sand, tilsidesætter nye værdier fra interaktive loggere de gamle.
Den bedste del af Signale er evnen til at bortfiltrere hemmelighedsfulde eller følsomme oplysninger. Flere hemmeligheder er gemt i et array. addSecrets() og clearSecrets() er de funktioner, der bruges til at tilføje og rydde hemmelighederne fra arrayet. Boostnote, Docz, Shower, Taskbook og Vant bruger Signale til logning. Syntaksen for at kalde API’er fra Signale er som følger:
signale.<logger>(message[,message]|messageObj|errorObj)
Antallet af Signale-downloads er over 1 million på tidspunktet for skrivning af denne artikel.
Tracer
Tracer bruges til at producere detaljerede logmeddelelser. Logningsmeddelelser består af tidsstempler, filnavne, linjenumre og metodenavne. Hjælpepakker kan installeres for at tilpasse output-logningsformatet. Hjælpepakkerne kan installeres ved hjælp af følgende kommando.
npm install -dev tracer
Tracer understøtter fil-, stream- og MongoDB-transport. Det understøtter farvekonsol og filterbetingelser i logning. I første omgang skal sporingen installeres ved hjælp af npm install. For det andet skal der oprettes et loggerobjekt, og typen af konsol skal vælges. Derefter kan de forskellige logniveauer eller typer specificeres over objektet for yderligere logning.
Tilpassede filtre kan oprettes ved at definere synkrone funktioner med den forretningslogik, der findes i funktionskroppen. Mikroskabeloner som tinytim kan også bruges til systemlogning.
Cabin.js
Cabin bruges til server- og klientsidelogning af node.js-applikationer. Det bruges, hvor maskering af følsomme og kritiske oplysninger er påkrævet. Dette inkluderer kreditkortnumre, BasicAuth Headers, salte, adgangskoder, CSRF-tokens og bankkontonumre. Kodestykket nedenfor viser logning ved hjælp af Cabin.js.
const Cabin = require('cabin');
const cabin = new Cabin();
cabin.info('hello world');
cabin.error(new Error('oops!'));
Den består af mere end 1600 feltnavne. Det følger også princippet om Bring Your Own Logger (BYOL). Dette gør den kompatibel med forskellige andre loggere som Axe, Pino, Bunyan, Winston osv. Det reducerer lageromkostningerne på diske på grund af automatisk streaming og Cabin-buffere. Den er kompatibel på tværs af platforme og nem at fejlfinde.
Logning på serversiden kræver brug af middleware til routing og automatisk outputlogning. Logning på browsersiden kræver XHR-anmodninger og scripts. Den bruger Axe, der viser metadata, dvs. data om data, stakspor og andre fejl. SHOW_STACK og SHOW_META er booleske variabler sat til sand eller falsk for at vise eller skjule stakspor og metadata.
Npmlog
Npmlog er en grundlæggende type logger, som npm bruger. Nogle af de anvendte logningsmetoder er level, record, maxRecordSize, prefixStyle, heading og stream. Det understøtter også farvet logning. De forskellige logningsniveauer er fjollede, ordrettede, info, advare, http og fejl. Et eksempel på kodestykket til brug af npm-loggen er vist nedenfor.
var log = require('npmlog')
// additional stuff ---------------------------+
// message ----------+ |
// prefix ----+ | |
// level -+ | | |
// v v v v
log.info('fyi', 'I have a kitty cat: %j', myKittyCat)
Alle meddelelser undertrykkes, hvis “Infinity” er angivet som logniveau. Hvis “-Infinity” er angivet som logniveau, skal muligheden for at se logningsmeddelelser være aktiveret for at se logfilerne.
Hændelser og meddelelsesobjekter bruges til logning. Præfiksmeddelelser udsendes, når præfikshændelser bruges. Stilobjekter bruges til at formatere logfilerne, som at tilføje farve til tekst og baggrund, skrifttype som fed, kursiv, understregning osv. Nogle npm-logpakker er brolog, npmlogger, npmdate-log osv.
Roarr
Roarr er en logger til Node.js, der ikke kræver initialisering og producerer strukturerede data. Den har CLI og miljøvariabler. Den er browserkompatibel. Den kan integreres med Fastify, Fastify, Elastic Search osv. Den kan skelne mellem applikationskode og afhængighedskode. Hver logmeddelelse består af en kontekst, besked, sekvens, tid og version. Forskellige logniveauer inkluderer sporing, debug, info, advarsel, fejl og fatal. Et eksempel på kodestykket til, hvordan logningen udføres, er Roarr, er som følger:
import {
ROARR,
} from 'roarr';
ROARR.write = (message) => {
console.log(JSON.parse(message));
};
Serialisering af fejl kan også udføres, hvilket betyder, at instansen med fejlen kan logges sammen med objektets kontekst. Nogle af miljøvariablerne, som er specifikke for Node.js og Roarr, er ROARR_LOG og ROARR_STREAM. “adopter” er en funktion, der bruges sammen med node.js til at videregive kontekstegenskaberne til forskellige niveauer. Underordnede funktioner kan også bruges med middleware, mens der logges.
Afsluttende ord
Logning er en metode til at holde styr på forskellige aktiviteter og begivenheder under udførelsen af et program. Logning spiller en afgørende rolle i kodefejlfinding. Det hjælper også med at øge kodelæsbarheden. Node.js er et open source, javascript-kørselstidsmiljø. Nogle af de bedste Node.js-loggere er Pino, Winston, Bunyan, Signale, Tracer, Npmlog osv. Hver type logger har sine egne funktioner som profilering, filtrering, streaming og transport.
Nogle loggere understøtter farvede konsoller, og nogle er velegnede til at håndtere følsomme oplysninger. Detaljerede og formaterede logfiler hjælper udviklere mest, mens de forsøger at rette fejl i deres kode. JSON-format foretrækkes generelt til logning, fordi det logger data i form af nøgle-værdi-par, hvilket gør det brugervenligt.
Loggere kan også integreres med andre applikationer og er kompatible med flere browsere. Det er altid tilrådeligt at undersøge de behov og applikationer, du bygger, før du vælger den type logger, du vil bruge.
Du kan også se på, hvordan du installerer Node.js og NPM på Windows og macOS.