Kjemper du med å finne feil i koden din? Er du på utkikk etter loggføringsløsninger som kan forenkle feilsøkingen? Les videre for å lære mer om dette.
Utvikling av programvare består av ulike stadier: kravinnsamling, analyse, koding, testing og vedlikehold. Av disse krever koding/utviklingsfasen mest tid og innsats. Programvareingeniører håndterer syntaksfeil, logiske feil og kjøretidsfeil. Syntaksfeil blir oppdaget ved kompilering og oppstår fordi koden ikke følger reglene for et bestemt programmeringsspråk.
Logiske feil og kjøretidsfeil, derimot, blir ikke identifisert av det integrerte utviklingsmiljøet (IDE). Disse feilene er ofte vanskelige å feilsøke og rette. Feilretting er en tidkrevende prosess som krever mye feilsøking.
Feilsøking er en prosedyre der man prøver å forstå hvorfor den skrevne koden ikke oppfører seg som forventet. Det er lett å løse problemet når vi kjenner til feilen og de nøyaktige kodelinjene der feilen oppstår. Logging er derfor et svært nyttig verktøy for å feilsøke kode.
Hva er logging?
Logging er en teknikk der meldinger fanges opp under kjøring av et program. Man bør kun logge meldinger som kan være til hjelp ved feilsøking. Det er derfor svært viktig å vite når man skal legge til loggsetninger i koden. Det er også viktig å skille mellom ulike loggsetninger. Det finnes ulike nivåer for logging, som info, advarsel, feil, feilsøking og detaljert. Feil- og advarselsmeldinger brukes til unntakshåndtering.
Data som returneres fra funksjoner, resultater etter manipulering av arrays, data hentet fra API-er, er eksempler på data som kan logges ved hjelp av info-setninger. Feilsøkingslogger og detaljerte logger gir en utfyllende beskrivelse av feil.
Feilsøkingsloggen gir informasjon om stakksporing, input/output-parametre osv. «Verbose»-loggen er ikke like detaljert som «debug»-loggen, men den gir en oversikt over alle hendelser som har skjedd. Logger skrives til konsollen, filer og utdatastrømmen. Loggadministrasjonsverktøy kan brukes for strukturert og formatert logging.
Node.js-logging
Node.js er et JavaScript-kjøretidsmiljø. Node.js-applikasjoner er asynkrone og ikke-blokkerende, og de brukes i dataintensive og sanntidssystemer. Den beste måten å lære mer om Node.js på er å studere Node.js-opplæringen og den tilhørende dokumentasjonen. Logging er nødvendig for forbedret ytelse, feilsøking og feilsporing. Logging i Node.js kan utføres ved hjelp av den innebygde funksjonen `console.log`. Debug-funksjonen kan også kobles sammen med ulike pakker for effektiv bruk.
Mellomvare brukes til å håndtere forespørsler og svar. Mellomvare kan være en applikasjon eller et hvilket som helst annet JavaScript-rammeverk. Logging i mellomvare kan gjøres gjennom applikasjoner og rutere. For å installere loggere i Node.js, må man bruke kommandoen `npm` eller `yarn install`.
`npm` står for «Node Package Manager», og `YARN` står for «Yet Another Resource Negotiator». Yarn foretrekkes imidlertid fremfor npm da den er raskere og installerer pakker parallelt.
Noen av de beste Node.js-loggerne er listet opp nedenfor:
Pino
Pino er et bibliotek som regnes som en av de beste loggerne for Node.js-applikasjoner. Det er åpen kildekode, ekstremt raskt, og logger uttalelser i et lettlest JSON-format. Noen av Pino sine loggnivåer er debug, advarsel, feil og info. En Pino-loggerinstans kan importeres til prosjektet, og `console.log`-setningene må erstattes med `logger.info`-setninger.
Bruk følgende kommando for å installere Pino:
$ npm install pinoLoggene som genereres er forseggjorte og i JSON-format, og viser linjenummeret til loggen, loggtypen, tidspunktet da den ble logget osv. Pino forårsaker minimal overhead i en applikasjon og er ekstremt fleksibel ved behandling av logger.
Pino kan integreres med webrammeverk som Hapi, Restify, Express, osv. Logger som genereres av Pino, kan også lagres i filer. Den bruker Worker-tråder for drift og er kompatibel med TypeScript.
Winston
Winston støtter logging for ulike webrammeverk med hovedfokus på fleksibilitet og utvidbarhet. Den støtter ulike typer transport og kan lagre logger på forskjellige fillokasjoner. Transporter er steder der loggmeldingene lagres.
Sammen med noen innebygde transporter som Http, Console, File og Stream, støtter den også andre transporter som Cloud Watch og MongoDB. Den utfører logging under ulike nivåer og formater. Loggnivåer indikerer alvorlighetsgraden av problemet.
De ulike loggnivåene er som vist nedenfor:
{
error: 0,
warn: 1,
info: 2,
http: 3,
verbose: 4,
debug: 5,
silly: 6
}
Loggutdataformatet kan tilpasses, filtreres og kombineres. Logger inkluderer informasjon om tidsstempel, etiketter knyttet til en logg, forløpte millisekunder fra forrige logg osv.
Winston håndterer også unntak og uoppdagede løfter. Den tilbyr tilleggsfunksjoner som arkivering av spørringer, strømmelogger osv. Først må man installere Winston. Deretter opprettes et Winston-konfigurasjonsobjekt, sammen med transport for lagring av loggen. Et loggerobjekt opprettes ved hjelp av `createLogger()`-funksjonen, og loggmeldingen sendes til det.
Node-Bunyan
Bunyan brukes til rask logging i Node.js i JSON-format. Den har også et CLI-verktøy (Command Line Interface) for visning av logger. Den er lett og støtter ulike kjøretidsmiljøer som Node.js, Browserify, WebPack og NW.js. JSON-formatet til loggene blir ytterligere forskjønnet ved bruk av den vakre utskriftsfunksjonen. Logger har ulike nivåer som fatal, error, warn, info, debug og trace; hver er assosiert med en numerisk verdi.
Alle nivåer over det spesifiserte nivået for instansen logges. Bunyan stream er stedet hvor utdataene logges. Underkomponenter i en applikasjon kan logges ved å bruke `log.child()`-funksjonen. Alle underordnede loggere er avgrenset til en spesifikk overordnet applikasjon. Strømtypen kan være en fil, roterende fil, rådata osv. Kodeeksemplet for å definere en strøm vises nedenfor:
var bunyan = require('bunyan');
var log = bunyan.createLogger({
name: "foo",
streams: [
{
stream: process.stderr,
level: "debug"
},
...
]
});
Bunyan støtter også DTrace-logging. Sondene som er involvert i DTrace-logging inkluderer `log-trace`, `log-warn`, `log-error`, `log-info`, `log-debug` og `log-fatal`. Bunyan bruker serializers for å produsere loggene i JSON-format. Serialiseringsfunksjoner gir ikke unntak og er defensive.
Loggnivå
Loglevel brukes for logging i JavaScript-applikasjoner. Det er også en av Node.js sine beste loggere, da den er lett og enkel. Den logger det gitte nivået og bruker en enkelt fil uten avhengigheter for logging. Standard loggnivå er «advarsel». Loggutdataene er godt formatert sammen med linjenummer. Noen metoder som brukes for logging er sporing, feilsøking, advarsel, feil og info.
De er motstandsdyktige mot feil i alle miljøer. `getLogger()` er metoden som brukes for å hente loggerobjektet. Den kan også kombineres med andre plugins for å utvide funksjonene. Noen av pluginene inkluderer `loglevel-plugin-prefix`, `loglevel-plugin-remote`, ServerSend og DEBUG. Pluginen for å legge til prefiksmeldinger til logging 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
Byggene kjøres ved hjelp av `npm run dist`-kommandoen, og testene kan kjøres med `npm-test`-kommandoen. Loggnivå støtter Webjar-, Bower- og Atmosphere-pakker. En ny versjon av Loglevel lanseres hver gang nye funksjoner legges til.
Signale
Signale består av 19 loggere for JavaScript-applikasjoner. Den støtter TypeScript og scoped logging. Den har tidtakere som hjelper deg med å logge tidsstempel, data og filnavn. I tillegg til de 19 loggerne som `await`, `complete`, `fatal`, `fav`, `info`, osv., kan man også lage tilpassede loggere.
Egendefinerte loggere opprettes ved å definere et JSON-objekt og felter med loggerdata. Interaktive loggere kan også opprettes. Når en interaktiv logger er satt til sann, vil nye verdier fra interaktive loggere overstyre de gamle.
Det beste med Signale er muligheten til å filtrere ut konfidensiell eller sensitiv informasjon. Flere hemmeligheter lagres i en array. `addSecrets()` og `clearSecrets()` er funksjonene som brukes for å legge til og fjerne hemmeligheter fra arrayen. Boostnote, Docz, Shower, Taskbook og Vant bruker Signale for logging. Syntaksen for å kalle API-er fra Signale er som følger:
signale.<logger>(message[,message]|messageObj|errorObj)Antall Signale-nedlastinger er over 1 million på tidspunktet for denne artikkelen.
Tracer
Tracer brukes til å produsere detaljerte loggmeldinger. Loggmeldingene består av tidsstempler, filnavn, linjenumre og metodenavn. Hjelpepakker kan installeres for å tilpasse utdataloggingsformatet. Hjelpepakkene kan installeres ved hjelp av følgende kommando.
npm install -dev tracerTracer støtter fil-, stream- og MongoDB-transport. Den støtter fargekonsoll og filterforhold i logging. Først må trackeren installeres med `npm install`. Deretter må et loggerobjekt opprettes, og typen konsoll må velges. Til slutt kan de ulike loggnivåene eller -typene spesifiseres over objektet for videre logging.
Tilpassede filtre kan opprettes ved å definere synkrone funksjoner med forretningslogikken i funksjonskroppen. Mikromaler som tinytim kan også brukes til systemlogging.
Cabin.js
Cabin brukes til server- og klientsidelogging av Node.js-applikasjoner. Den brukes når maskering av sensitiv og kritisk informasjon er nødvendig. Dette inkluderer kredittkortnumre, BasicAuth-overskrifter, salt, passord, CSRF-tokens og bankkontonumre. Kodebiten nedenfor viser logging med Cabin.js.
const Cabin = require('cabin');
const cabin = new Cabin();
cabin.info('hello world');
cabin.error(new Error('oops!'));
Den består av mer enn 1600 feltnavn. Den følger også prinsippet «Bring Your Own Logger» (BYOL). Dette gjør den kompatibel med forskjellige andre loggere som Axe, Pino, Bunyan, Winston, osv. Den reduserer lagringskostnadene på disker på grunn av automatisk strømming og Cabin-buffere. Den er kompatibel på tvers av plattformer og enkel å feilsøke.
Logging på serversiden krever bruk av mellomvare for ruting og automatisk utdatalogging. Logging på nettlesersiden krever XHR-forespørsler og skript. Den bruker Axe som viser metadata, dvs. data om data, stackspor og andre feil. `SHOW_STACK` og `SHOW_META` er boolske variabler satt til `sann` eller `usann` for å vise eller skjule stakkspor og metadata.
Npmlog
Npmlog er en grunnleggende type logger som npm bruker. Noen av loggingsmetodene som brukes er nivå, post, `maxRecordSize`, `prefixStyle`, `heading` og `stream`. Den støtter også farget logging. De ulike loggnivåene er dumme, detaljerte, info, advarsel, http og feil. Et eksempel på kodebit for bruk av npm-loggen vises 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 meldinger undertrykkes hvis «Infinity» er spesifisert som loggnivå. Hvis «-Infinity» er spesifisert som loggnivå, må alternativet for å se loggmeldinger være aktivert for å vise loggene.
Hendelser og meldingsobjekter brukes for logging. Prefiksmeldinger sendes ut når prefikshendelser brukes. Stilobjekter brukes for å formatere loggene, som å legge til farge på tekst og bakgrunn, skriftstil som fet, kursiv, understreking osv. Noen npm-loggpakker er `brolog`, `npmlogger`, `npmdate-logg` osv.
Roarr
Roarr er en logger for Node.js som ikke krever initialisering og produserer strukturerte data. Den har CLI og miljøvariabler. Den er kompatibel med nettlesere. Den kan integreres med Fastify, Fastify, Elastic Search osv. Den kan skille mellom applikasjonskode og avhengighetskode. Hver loggmelding består av en kontekst, melding, sekvens, tid og versjon. Ulike loggnivåer inkluderer sporing, feilsøking, info, advarsel, feil og fatal. Et eksempel på kodebiten for hvordan loggingen gjøres med Roarr, er som følger:
import {
ROARR,
} from 'roarr';
ROARR.write = (message) => {
console.log(JSON.parse(message));
};
Serialisering av feil kan også gjøres, noe som betyr at instansen med feilen kan logges sammen med konteksten til objektet. Noen av miljøvariablene som er spesifikke for Node.js og Roarr, er `ROARR_LOG` og `ROARR_STREAM`. «Adoptere» er en funksjon som brukes med Node.js for å overføre kontekstegenskapene til forskjellige nivåer. Underordnede funksjoner kan også brukes med mellomvare under logging.
Siste ord
Logging er en metode for å holde oversikt over ulike aktiviteter og hendelser under kjøring av et program. Logging spiller en viktig rolle i kodefeilsøking. Det bidrar også til å øke kodens lesbarhet. Node.js er et åpen kildekode, JavaScript-kjøretidsmiljø. Noen av de beste Node.js-loggerne er Pino, Winston, Bunyan, Signale, Tracer, Npmlog, osv. Hver loggertype har sine egne funksjoner som profilering, filtrering, strømming og transport.
Noen loggere støtter fargede konsoller, og noen er egnet for håndtering av sensitiv informasjon. Detaljerte og formaterte logger hjelper utviklere mest når de prøver å fikse feil i koden sin. JSON-format er generelt foretrukket for logging, fordi det logger data i form av nøkkelverdi-par som gjør det brukervennlig.
Loggere kan også integreres med andre applikasjoner og er kompatible med flere nettlesere. Det er alltid lurt å se nærmere på behovene og applikasjonene du bygger før du velger hvilken type logger du skal bruke.
Du kan også se på hvordan du installerer Node.js og NPM på Windows og macOS.