Una guida alla registrazione di Node.js

Blog

Originariamente pubblicato da DOMINIK KUNDEL a twilio.com



Quando inizi a sviluppare in JavaScript, una delle prime cose che probabilmente imparerai è come registrare le cose sulla console usando |_+_|. Se cerchi come eseguire il debug di JavaScript troverai centinaia di post di blog e articoli StackOverflow che ti indicano 'semplicemente' |_+_| esso. E poiché è una pratica così comune, abbiamo persino iniziato ad avere regole linter come |_+_| per assicurarci di non lasciare dichiarazioni di log accidentali nel nostro codice di produzione. Ma cosa succede se in realtà volessimo registrare qualcosa intenzionalmente per fornire maggiori informazioni?

In questo post del blog esamineremo varie situazioni in cui desideri registrare informazioni, qual è la differenza tra |_+_| e |_+_| in Node.js è, e come puoi spedire l'accesso alle tue librerie senza ingombrare la console degli utenti.



console.log

Teoria prima: dettagli importanti per Node.js

Mentre sei in grado di usare |_+_| oppure |_+_| nel browser così come in Node.js, c'è una cosa importante da tenere a mente quando si usa Node.js. Quando scrivi il seguente codice in Node.js in un file chiamato |_+_|:

console.log

Ed eseguilo nel terminale usando |_+_| vedrai l'output dei due direttamente uno sotto l'altro:



Tuttavia, sebbene questi due possano sembrare uguali, in realtà vengono trattati dal sistema in modo diverso. Se controlli |_+_| sezione della documentazione di Node.js vedrai che |_+_| sta stampando su |_+_|mentre |_+_| usa |_+_|.

Ogni processo ha tre predefiniti |_+_| con cui può funzionare. Quelli sono |_+_|, |_+_| e |_+_|. Il |_+_| stream sta gestendo l'input che arriva al tuo processo. Ad esempio la pressione di un pulsante o un output reindirizzato (ci arriveremo tra un secondo). Il |_+_| stream è pensato per l'output della tua applicazione. Infine |_+_| è pensato per i messaggi di errore. Se vuoi capire perché |_+_| esiste e quando usarlo, dai un'occhiata a questo articolo .

In poche parole, questo ci consente di utilizzare gli operatori redirect (|_+_|) e pipe (|_+_|) per lavorare con informazioni di errore e diagnostiche separate dal risultato effettivo di un'applicazione. Mentre |_+_| ci permette di reindirizzare l'output di un comando in un file, |_+_| ci permette di reindirizzare l'output di |_+_| in un file. Ad esempio, questo comando farebbe passare 'Hello there' in un file chiamato |_+_| e 'Bye bye' in un file chiamato |_+_|.

no-console

Quando vuoi registrarti?

Ora che abbiamo imparato un po' dell'aspetto tecnico sottostante della registrazione, parliamo un po' dei diversi casi d'uso in cui potresti voler registrare qualcosa. In genere questi casi d'uso rientrano in una delle seguenti categorie:

In questo post del blog salteremo i primi due e ci concentreremo sui tre basati su Node.js.

I log delle tue applicazioni server

C'è una serie di motivi per cui potresti voler registrare le cose sul tuo server. La registrazione delle richieste in entrata, ad esempio, ti consente di estrarre cose come le statistiche, ad esempio quanti utenti 404 stanno colpendo, quali potrebbero essere o cosa |_+_| viene usato. E vuoi anche sapere quando qualcosa è andato storto e perché.

Se vuoi provare le cose che seguono in questa parte del post, assicurati di creare una nuova directory di progetto. Crea un |_+_| nella directory del progetto per il codice che useremo ed eseguiremo quanto segue per inizializzare un progetto e installare |_+_|:

console.log

Configuriamo un server con un middleware che semplicemente |_+_| ogni tua richiesta Inserisci quanto segue nel |_+_| file:

console.error

Stiamo usando |_+_| qui per registrare l'intero oggetto. |_+_| usa |_+_| sotto il cofano che supporta in aggiunta a |_+_| altri segnaposto. Puoi leggili nella documentazione di Node.js .

javascript cast per galleggiare

Quando esegui |_+_| per eseguire il tuo server e navigare verso http://localhost:3000 noterai che stamperà molte informazioni di cui non abbiamo davvero bisogno.

Se lo cambi in |_+_| per non stampare l'intero oggetto non avremo nemmeno molte informazioni

Potremmo scrivere la nostra funzione di registro che stampi solo le cose che ci interessano, ma prima facciamo un passo indietro e parliamo di ciò che di solito ci interessa. Mentre il messaggio è spesso al centro della nostra attenzione, in realtà ci sono spesso informazioni aggiuntive di cui potremmo aver bisogno. Informazioni come:

  • Timestamp - per sapere quando sono accadute le cose
  • Nome computer/server - nel caso si stia eseguendo un sistema distribuito
  • ID processo - nel caso in cui tu stia eseguendo più processi Nodo usando qualcosa come |_+_|
  • Messaggio: un messaggio vero e proprio con del contenuto
  • Stack Trace - nel caso in cui registriamo un errore
  • Forse alcune variabili/informazioni aggiuntive

Inoltre, ora che sappiamo che tutto va a |_+_| e |_+_| in ogni caso, probabilmente vorremmo diversi livelli di registro e la possibilità di configurare e filtrare i nostri registri in base a essi.

Possiamo ottenere tutto questo accedendo a varie parti di |_+_| e scrivendo un sacco di JavaScript, ma la cosa migliore di Node.js è che abbiamo ottenuto |_+_| ecosistema e ci sono già una varietà di librerie che possiamo usare. Alcuni di questi sono:

  • console.log
  • console.error
  • index.js
  • node index.js

Personalmente mi piace |_+_| perché è veloce e ha un bell'ecosistema. Vediamo come usare |_+_| può aiutarci con la registrazione. La cosa bella è che c'è già un |_+_| pacchetto che possiamo usare per registrare le richieste.

Installa entrambi |_+_| e |_+_|:

console

Successivamente aggiorna il tuo |_+_| file per utilizzare il logger e il middleware:

console.log

In questo frammento abbiamo creato un |_+_| istanza di |_+_| e passato nel |_+_| per creare un nuovo middleware logger da chiamare |_+_| insieme a. Inoltre abbiamo sostituito |_+_| all'avvio del server con |_+_| e ha aggiunto un ulteriore |_+_| al nostro percorso per mostrare diversi livelli di registro.

menu a discesa reattivo-nativo-ricercabile

Se riavvii il tuo server eseguendo di nuovo |_+_|, vedrai un output abbastanza diverso che stampa un JSON per ogni riga. Navigare verso http://localhost:3000 di nuovo e vedi un'altra riga di JSON aggiunta.

Se controlli questo JSON vedrai che contiene tutte le informazioni precedentemente menzionate come ad es. un timestamp. Potresti anche notare che il nostro |_+_| la dichiarazione non viene stampata. Questo perché dobbiamo cambiare il nostro livello di registro predefinito per renderlo visibile. Quando abbiamo creato il nostro |_+_| esempio impostiamo il valore a |_+_| il che significa che possiamo cambiare il valore attraverso quello, o accettare il valore predefinito di |_+_|. Eseguendo |_+_| possiamo regolare il livello di registro.

Prima di farlo, affrontiamo il fatto che l'output in questo momento non è realmente leggibile dall'uomo in questo momento. Questo è intenzionale. |_+_| segue una filosofia secondo cui, per motivi di prestazioni, è necessario spostare qualsiasi elaborazione dei registri in un processo separato tramite piping (usando |_+_|) l'output. Ciò include renderlo leggibile dall'uomo o caricarlo su un host cloud. Questi sono chiamati |_+_|. Dai un'occhiata al documentazione su |_+_| per sapere anche perché gli errori in |_+_| non sono scritti in |_+_|.

Usiamo lo strumento |_+_| per guardare una versione più leggibile dei log. Esegui nel tuo terminale:

stdout

Tutti i tuoi log verranno ora reindirizzati utilizzando |_+_| operatore nel |_+_| comando e il tuo output dovrebbe essere ripulito per contenere informazioni cruciali e dovrebbe essere colorato. Se lo richiedi http://localhost:3000 di nuovo dovresti vedere anche il tuo |_+_| Messaggio.

C'è una varietà di trasporti esistenti per abbellire o trasformare i tuoi registri. Potresti persino visualizzarli con gli emoji usando |_+_|. Questi saranno utili per il tuo sviluppo locale. Una volta eseguito il server in produzione, potresti voler reindirizzare i tuoi log in un altro trasporto , scrivili su disco usando |_+_| per elaborarli in un secondo momento o eseguire entrambe le operazioni utilizzando un comando come |_+_|.

Il documentazione conterrà anche informazioni su cose come la rotazione dei file di registro, il filtraggio e la scrittura dei registri su file diversi.

I registri della tua libreria

Ora che abbiamo visto come possiamo scrivere i log in modo efficiente per le nostre applicazioni server, perché non utilizzare la stessa tecnologia per le librerie che creiamo?

Il problema è che la tua libreria potrebbe voler registrare le cose per scopi di debug, ma in realtà non dovrebbe ingombrare l'applicazione del consumatore. Invece il consumatore dovrebbe essere in grado di abilitare i log se ha bisogno di eseguire il debug di qualcosa. La tua libreria dovrebbe essere silenziosa per impostazione predefinita e lasciare la scrittura dell'output all'utente.

Un buon esempio per questo è |_+_|. Ci sono molte cose che accadono sotto il cofano di |_+_| e potresti voler dare un'occhiata sotto il cofano quando esegui il debug della tua applicazione. Se consultiamo il |_+_| documentazione noterai che puoi anteporre un |_+_| al tuo comando in questo modo:

console.error

Se esegui il comando con un'app esistente, vedrai molti output aggiuntivi che ti aiuteranno a eseguire il debug del problema.

Se non hai abilitato la registrazione di debug, non vedrai nulla di tutto ciò. Questo viene fatto attraverso un pacchetto opportunamente chiamato |_+_|. Ci permette di scrivere messaggi sotto un 'spazio dei nomi' e se l'utente della libreria include lo spazio dei nomi o un carattere jolly che lo corrisponda nel loro |_+_| variabile d'ambiente , li emetterà. Per usare |_+_| libreria, prima installala:

stderr

Proviamolo creando un nuovo file che simulerà la nostra libreria chiamato |_+_| e inserisci il seguente codice al suo interno:

streams

Questo crea un nuovo |_+_| logger con lo spazio dei nomi |_+_| e quindi registra due messaggi su di esso. Usiamolo nel nostro |_+_| dal capitolo precedente:

stdin

Se riesegui il server ma questa volta con |_+_| stampa i log di debug per la nostra 'libreria'.

La cosa bella è che se gli utenti della tua libreria vogliono inserire queste informazioni di debug nel loro |_+_| log, possono usare una libreria chiamata |_+_| di |_+_| team per formattare correttamente quei log.

Installa la libreria usando:

stdout

|_+_| deve essere inizializzato prima del nostro primo utilizzo di |_+_|. Il modo più semplice per farlo è usare |_+_| o stderr bandiera di Node.js per richiedere il modulo prima di avviare il nostro script. Riesegui il tuo server con un comando come il seguente (supponendo che tu abbia installato |_+_|) :

stdin

Ora vedrai i tuoi registri di debug della libreria nello stesso formato dei registri dell'applicazione.

Il tuo output CLI

L'ultimo caso che tratteremo in questo post del blog è il caso speciale di registrazione per CLI piuttosto che per librerie. La mia filosofia qui è di mantenere i log logici separati dai 'log' di output della CLI. Per qualsiasi log logico, dovresti usare una libreria come |_+_|. In questo modo tu o altri potete riutilizzare la logica senza essere vincolati dal caso d'uso specifico della vostra CLI.

Quando crei una CLI con Node.js potresti voler rendere le cose belle aggiungendo colori, filatori o formattando le cose in un particolare modo visivamente accattivante. Tuttavia, quando crei la tua CLI, ci sono alcuni scenari che dovresti tenere a mente.

Uno scenario è che la tua CLI potrebbe essere utilizzata nel contesto di un sistema di integrazione continua (CI) e quindi potresti voler eliminare i colori o qualsiasi output decorativo di fantasia. Alcuni sistemi CI impostano un flag di ambiente chiamato |_+_|. Se vuoi essere più sicuro per verificare se sei in un CI è usando un pacchetto come |_+_| che ha già il supporto per un sacco di sistemi CI.

Alcune librerie come |_+_| rileva già i CI per te e rilascia i colori per te. Diamo un'occhiata a come appare.

Installa |_+_| usando |_+_| e creare un file chiamato |_+_|. Inserisci quanto segue:

stdout

Ora, se eseguissi questo script usando |_+_| vedrai un output colorato.

Ma se lo esegui con |_+_| vedrai che il colore è soppresso:

L'altro scenario che vuoi tenere a mente è se il tuo |_+_| è in esecuzione in modalità terminale. Significa il contenuto scritto su un terminale. Se è così, possiamo mostrare tutto il bel risultato usando cose come |_+_|. In caso contrario, è probabile che l'output venga reindirizzato in un file o reindirizzato da qualche parte.

Puoi controllare se|_+_|, |_+_| oppure |_+_| sono in modalità terminale selezionando |_+_| attributo sul rispettivo flusso. Ad esempio: |_+_|. |_+_| sta per telescrivente e in questo caso specifico per Terminal.

I valori possono differire per ciascuno dei tre flussi a seconda di come è stato avviato il processo Node.js. Puoi leggere di più a riguardo nel sezione I/O di processo della documentazione di Node.js .

come acquistare criptovalute su bitmart

Vediamo come il valore di |_+_| varia nelle diverse situazioni. Aggiorna il tuo |_+_| file per verificarlo:

stderr

Ora esegui |_+_| nel tuo terminale e vedi |_+_| stampato seguito dal nostro messaggio colorato.

Successivamente esegui la stessa cosa ma reindirizza l'output su un file e controlla il contenuto in seguito eseguendo:

stderr

Vedrai che questa volta ha stampato |_+_| seguito da un semplice messaggio non colorato perché il reindirizzamento del |_+_| disattivato la modalità terminale di |_+_|. Da |_+_| usa |_+_| che sotto il cofano controlla tra l'altro per |_+_| sul rispettivo flusso.

Strumenti come |_+_| prenditi cura di questo comportamento già per te, tuttavia, quando sviluppi una CLI dovresti sempre essere consapevole delle situazioni in cui la tua CLI potrebbe essere eseguita in modalità CI o in cui l'output viene reindirizzato. Può anche aiutarti a migliorare ulteriormente l'esperienza della tua CLI. Ad esempio puoi organizzare i tuoi dati in modo carino nel terminale e se |_+_| è |_+_| si passa a un modo più facile da analizzare.

In sintesi

Iniziare con JavaScript e registrare la prima riga utilizzando |_+_| è veloce, ma quando porti il ​​tuo codice in produzione, c'è molto di più che dovresti considerare sulla registrazione. Questo post è puramente un'introduzione ai vari modi e alle soluzioni di registrazione disponibili. Non contiene tutto ciò che devi sapere. Ti consiglio di dare un'occhiata ad alcuni dei tuoi progetti open source preferiti per vedere come risolvono i problemi di registrazione e quali strumenti usano. Ora vai e registra tutte le cose e non stampare i tuoi registri

Se conosci o trovi strumenti che dovrei assolutamente menzionare o se hai domande, sentiti libero di scrivermi due righe. Non vedo l'ora di vedere cosa costruisci.

Originariamente pubblicato da DOMINIK KUNDEL a twilio.com

==============================

Grazie per aver letto

Se ti è piaciuto questo post, condividilo con tutti i tuoi amici di programmazione!

Seguimi su Facebook | Twitter

Per saperne di più

? NestJS Zero to Hero - Sviluppo back-end dattiloscritto moderno

? Il corso completo per sviluppatori Node.js (3a edizione)

? Completa Next.js con React & Node - Beautiful Portfolio App

reagisci al checkout della striscia nativa

? Angular e NodeJS - La guida allo stack MEAN

? NodeJS - La guida completa (incl. MVC, API REST, GraphQL)

? Docker per i progetti Node.js da un capitano Docker

? Introduzione a MySQL con Node.js - Impara a usare MySQL con Node!

? Node.js Absolute Beginners Guide - Impara Node From Scratch


#node-js #javascript #web-development

www.twilio.com

Una guida alla registrazione di Node.js

Una guida alla registrazione di Node.js - La registrazione è una parte importante del supporto dell'intero ciclo di vita dell'applicazione. Dalla creazione al debugging alla pianificazione di nuove funzionalità...