Sliter du med å feilsøke koden din? Leter du etter noen loggløsninger som kan gjøre feilsøking enklere? Les videre for å lære mer.
Programvareutvikling går gjennom flere faser: kravinnsamling, analyse, koding, testing og vedlikehold. Av alle disse fasene krever koding/utviklingsfasen mye tid og krefter. Programvareingeniører håndterer syntaksfeil, logiske feil og kjøretidsfeil. Syntaktiske feil identifiseres ved kompilering og oppstår på grunn av at koden ikke overholder reglene for et programmeringsspråk.
På den annen side kan logiske feil og kjøretidsfeil ikke identifiseres av det integrerte utviklingsmiljøet (IDE) og er ofte vanskelige å feilsøke og fikse. Å løse feil er en tidkrevende prosess og krever mye feilsøking.
Feilsøking er en prosess der man prøver å forstå hvorfor koden som er skrevet ikke fungerer som forventet. Det er enkelt å løse problemet når vi kjenner feilen og de nøyaktige linjene i koden der den oppstår. Derfor er logging veldig nyttig for å feilsøke kode.
Innholdsfortegnelse
Hva er logging?
Logging er en teknikk der meldinger fanges opp under kjøringen av et program. Man må bare logge de meldingene, som kan hjelpe dem med feilsøking. Så det er ekstremt viktig å vite når du skal legge til loggsetninger i koden. Det er også like viktig å skille mellom loggsetninger. Det er forskjellige nivåer i logging, som info, advarsel, feil, feilsøking og detaljert. Feil- og advarselsmeldinger brukes til unntakshåndtering.
Data som returneres fra funksjoner, resultater etter array-manipulering, data hentet fra APIer, etc., er noen eksempler på data som kan logges ved hjelp av info-setninger. Feilsøkingsloggene og de detaljerte loggene brukes til å gi en detaljert beskrivelse av feilene.
Feilsøkingsloggen gir informasjon om stabelsporing, input-output parametere osv. «Verbose» er ikke like detaljert som «debug»-loggen, men gir en liste over alle hendelsene som har skjedd. Logger skrives ut til konsollen, filene og utdatastrømmen. Loggadministrasjonsverktøy kan brukes til strukturert og formatert logging.
Node.js-logging
Nodejs er et javascript kjøretidsmiljø. Node.js-applikasjoner er asynkrone og ikke-blokkerende, og brukes i dataintensive og sanntidssystemer. Den beste måten å lære mer om Node.js på er å gå gjennom Node.js-opplæringen og dens dokumentasjon. Logging er nødvendig for forbedret ytelse, feilsøking og feilsporing. Innlogging Node.js kan gjøres ved å bruke den innebygde funksjonen console.log. Debug-funksjonen er også koblet sammen med flere pakker og kan brukes effektivt.
Mellomvare brukes til å administrere forespørsler og svar. Mellomvare kan være en applikasjon eller et hvilket som helst annet Javascript-rammeverk. Innlogging mellomvare kan gjøres gjennom applikasjoner og rutere. Enhver Node.js-logger må bruke kommandoen npm eller yarn install for å installere loggerne.
Npm står for «Node Package Manager», og YARN står for «Yet Another Resource Negotiator». Imidlertid foretrekkes Yarn fremfor npm da det er raskere og installerer pakker parallelt.
Noen av de beste Node.js-loggerne er oppført nedenfor:
Pino
Pino er et bibliotek som er en av de beste loggerne for Node.js-applikasjoner. Den er åpen kildekode, ekstremt rask, og logger uttalelsene i et lettlest JSON-format. Noen av Pino-loggnivåene er – feilsøking, advarsel, feilmeldinger og infomeldinger. En Pino-logger-forekomst kan importeres til prosjektet, og console.log-setningene må erstattes med logger.info-setninger.
Bruk følgende kommando for å installere Pino:
$ npm install pino
Loggene som genereres er forseggjorte og i JSON-format, og fremhever linjenummeret til loggen, typen logg, tidspunktet da den ble logget osv. Pino forårsaker minimal overheadlogging i en applikasjon og er ekstremt fleksibel under behandling av logger.
Pino kan integreres med nettrammeverk som Hapi, Restify, Express, etc. Logger generert 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 nettrammeverk med hovedfokus på fleksibilitet og utvidbarhet. Den støtter flere typer transport og kan lagre logger på forskjellige filplasseringer. Transporter er steder hvor loggmeldingene er lagret.
Sammen med noen innebygde transporter som Http, Console, File og Stream, støtter den andre transporter som Cloud Watch og MongoDB. Den gjør logging under forskjellige nivåer og formater. Loggnivåer indikerer alvorlighetsgraden av problemet.
De ulike loggingsnivå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 også. Logger inkluderer informasjon om tidsstemplet, etiketter knyttet til en logg, forløpte millisekunder fra forrige logg osv.
Winston håndterer også unntak og uoppdagede løfter. Det gir tilleggsfunksjoner som arkivering av spørringer, strømmelogger osv. For det første 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 for rask logging i node.js i JSON-format. Den har også et CLI-verktøy (Command Line Interface) for visning av loggene. Den er lett og støtter ulike kjøretidsmiljøer som Node.js, Browserify, WebPack og NW.js. JSON-formatet til loggene forskjønnes ytterligere ved å bruke 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 nivået som er angitt for forekomsten, logges. Bunyan stream er et sted hvor utgangene logges. Underkomponenter av 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 er vist 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 beste loggere siden den er lett og enkel. Den logger det gitte nivået og bruker en enkelt fil uten avhengigheter for logging. Standard loggnivå er «advarsel». Loggutgangene 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 til å 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. Programtillegget 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
Byggingene kjøres ved å bruke npm run dist-kommandoen, og testene kan kjøres med npm-testkommandoen. Loggnivå støtter Webjar-, Bower- og Atmosphere-pakker. En ny versjon av Loglevel utgis hver gang nye funksjoner legges til.
Signale
Signale består av 19 loggere for Javascript-applikasjoner. Den støtter TypeScript og scoped logging. Den består av tidtakere som hjelper deg med å logge tidsstemplet, dataene og filnavnet. Bortsett fra de 19 loggerne som await, complete, fatal, fav, info, etc., kan man lage tilpassede logger.
Egendefinerte logger opprettes ved å definere et JSON-objekt og felt med loggerdataene. Interaktive loggere kan også opprettes. Når en interaktiv logger er satt til sann, overstyrer nye verdier fra interaktive loggere de gamle.
Den beste delen av Signale er muligheten til å filtrere ut hemmelighetsfull eller sensitiv informasjon. Flere hemmeligheter er lagret i en matrise. addSecrets() og clearSecrets() er funksjonene som brukes for å legge til og fjerne hemmelighetene fra matrisen. Boostnote, Docz, Shower, Taskbook og Vant bruker Signale for logging. Syntaksen for å kalle APIer fra Signale er som følger:
signale.<logger>(message[,message]|messageObj|errorObj)
Antallet Signale-nedlastinger er over 1 million på tidspunktet for skriving av denne artikkelen.
Tracer
Tracer brukes til å produsere detaljerte loggmeldinger. Loggmeldinger består av tidsstempler, filnavn, linjenumre og metodenavn. Hjelpepakker kan installeres for å tilpasse utdataloggingsformatet. Hjelpepakkene kan installeres ved å bruke følgende kommando.
npm install -dev tracer
Tracer støtter fil-, stream- og MongoDB-transport. Den støtter fargekonsoll og filterforhold i logging. Til å begynne med må sporeren installeres med npm install. For det andre må et loggeobjekt opprettes, og typen konsoll må velges. Deretter kan de ulike loggnivåene eller typene spesifiseres over objektet for videre logging.
Tilpassede filtre kan opprettes ved å definere synkrone funksjoner med forretningslogikken som finnes i funksjonskroppen. Mikromaler som tinytim kan også brukes til systemlogging.
Cabin.js
Cabin brukes til server- og klientsidelogging av node.js-applikasjoner. Den brukes der maskering av sensitiv og kritisk informasjon er nødvendig. Dette inkluderer kredittkortnumre, BasicAuth-hoder, salter, 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 om Bring Your Own Logger (BYOL). Dette gjør den kompatibel med forskjellige andre loggere som Axe, Pino, Bunyan, Winston, etc. Det reduserer lagringskostnadene på disker på grunn av automatisk strøm 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 stabelspor 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 loggingsnivåene er dumme, detaljerte, info, advarsel, http og feil. En eksempelkodebit 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 å se loggene.
Hendelser og meldingsobjekter brukes til logging. Prefiksmeldinger sendes ut når prefikshendelser brukes. Stilobjekter brukes til å formatere loggene, som å legge til farge på tekst og bakgrunn, skriftstil som fet skrift, 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 nettleserkompatibel. 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 er 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 forekomsten 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 styr på ulike aktiviteter og hendelser under gjennomføringen av et program. Logging spiller en viktig rolle i kodefeilsøking. Det hjelper også med å øke kodelesbarheten. Node.js er et åpen kildekode, javascript kjøretidsmiljø. Noen av de beste Node.js-loggerne er Pino, Winston, Bunyan, Signale, Tracer, Npmlog, etc. Hver type logger har sine egne funksjoner som profilering, filtrering, streaming 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 mens de prøver å fikse feil i koden deres. 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 vil bruke.
Du kan også se på hvordan du installerer Node.js og NPM på Windows og macOS.