JavaScript'i asünkroonse konteksti levitamine: päringute jälgimine ja jätkamine AsyncLocalStorage'i abil

Tänapäevases serveripoolses JavaScripti arenduses, eriti Node.js-iga, on asünkroonsed operatsioonid kõikjal levinud. Olekute ja konteksti haldamine üle nende asünkroonsete piiride võib olla keeruline. See blogipostitus uurib asünkroonse konteksti levitamise kontseptsiooni, keskendudes sellele, kuidas kasutada AsyncLocalStorage'i, et saavutada tõhusalt päringute jälgimine ja jätkamine. Uurime selle eeliseid, piiranguid ja reaalseid rakendusi, tuues praktilisi näiteid selle kasutamise illustreerimiseks.

Asünkroonse konteksti levitamise mõistmine

Asünkroonse konteksti levitamine viitab võimele säilitada ja levitada konteksti teavet (nt päringu ID-d, kasutaja autentimisandmed, korrelatsiooni ID-d) üle asünkroonsete operatsioonide. Ilma korraliku konteksti levitamiseta muutub hajutatud süsteemides päringute jälgimine, logide korreleerimine ja jõudlusprobleemide diagnoosimine keeruliseks.

Traditsioonilised lähenemised konteksti haldamiseks tuginevad sageli kontekstiobjektide otsesele edastamisele funktsioonikõnede kaudu, mis võib viia paljusõnalise ja vigaderohke koodini. AsyncLocalStorage pakub elegantsemat lahendust, pakkudes viisi konteksti andmete salvestamiseks ja hankimiseks ühe täitmiskonteksti piires, isegi üle asünkroonsete operatsioonide.

AsyncLocalStorage'i tutvustus

AsyncLocalStorage on sisseehitatud Node.js moodul (saadaval alates Node.js v14.5.0), mis pakub viisi andmete salvestamiseks, mis on lokaalsed asünkroonse operatsiooni eluea jooksul. See loob sisuliselt salvestusruumi, mis säilib üle await-kõnede, lubaduste (promises) ja muude asünkroonsete piiride. See võimaldab arendajatel pääseda juurde konteksti andmetele ja neid muuta ilma neid otseselt edasi andmata.

AsyncLocalStorage'i peamised omadused:

• Automaatne konteksti levitamine: AsyncLocalStorage'i salvestatud väärtused levitatakse automaatselt üle asünkroonsete operatsioonide samas täitmiskontekstis.
• Lihtsustatud kood: Vähendab vajadust kontekstiobjekte otseselt funktsioonikõnede kaudu edastada.
• Parem jälgitavus: Hõlbustab päringute jälgimist ning logide ja mõõdikute korreleerimist.
• Lõimede ohutus (Thread-Safety): Pakub lõimede-ohutut juurdepääsu konteksti andmetele praeguses täitmiskontekstis.

AsyncLocalStorage'i kasutusjuhud

AsyncLocalStorage on väärtuslik mitmesugustes stsenaariumides, sealhulgas:

• Päringute jälgimine: Unikaalse ID määramine igale sissetulevale päringule ja selle levitamine kogu päringu elutsükli vältel jälgimise eesmärgil.
• Autentimine ja autoriseerimine: Kasutaja autentimisandmete (nt kasutaja ID, rollid, õigused) salvestamine kaitstud ressurssidele juurdepääsuks.
• Logimine ja auditeerimine: Päringuspetsiifiliste metaandmete lisamine logisõnumitele parema silumise ja auditeerimise jaoks.
• Jõudluse monitooring: Päringu sees olevate erinevate komponentide täitmise aja jälgimine jõudluse analüüsiks.
• Tehingute haldamine: Tehingu oleku haldamine üle mitme asünkroonse operatsiooni (nt andmebaasi tehingud).

Praktiline näide: päringute jälgimine AsyncLocalStorage'i abil

Illustreerime, kuidas kasutada AsyncLocalStorage'i päringute jälgimiseks lihtsas Node.js rakenduses. Loome vahevara, mis määrab igale sissetulevale päringule unikaalse ID ja teeb selle kättesaadavaks kogu päringu elutsükli vältel.

Koodinäide

Esmalt installige vajalikud paketid (kui vaja):

            npm install uuid express
            

              
                Copy
              
            
          

Siin on kood:

            // app.js
const express = require('express');
const { AsyncLocalStorage } = require('async_hooks');
const { v4: uuidv4 } = require('uuid');

const app = express();
const asyncLocalStorage = new AsyncLocalStorage();
const port = 3000;

// Vahevara päringu ID määramiseks ja selle salvestamiseks AsyncLocalStorage'i
app.use((req, res, next) => {
  const requestId = uuidv4();
  asyncLocalStorage.run(new Map(), () => {
    asyncLocalStorage.getStore().set('requestId', requestId);
    next();
  });
});

// Simuleerime asünkroonset operatsiooni
async function doSomethingAsync() {
  return new Promise(resolve => {
    setTimeout(() => {
      const requestId = asyncLocalStorage.getStore().get('requestId');
      console.log(`[Async] Request ID: ${requestId}`);
      resolve();
    }, 50);
  });
}

// Marsruudi käsitleja (Route handler)
app.get('/', async (req, res) => {
  const requestId = asyncLocalStorage.getStore().get('requestId');
  console.log(`[Route] Request ID: ${requestId}`);
  await doSomethingAsync();
  res.send(`Hello World! Request ID: ${requestId}`);
});

app.listen(port, () => {
  console.log(`App listening at http://localhost:${port}`);
});

            

              
                Copy
              
            
          

Selles näites:

1. Loome AsyncLocalStorage'i instantsi.
2. Määratleme vahevara, mis määrab igale sissetulevale päringule unikaalse ID, kasutades uuid teeki.
3. Kasutame asyncLocalStorage.run(), et käivitada päringu käsitleja AsyncLocalStorage'i kontekstis. See tagab, et kõik AsyncLocalStorage'i salvestatud väärtused on kättesaadavad kogu päringu elutsükli vältel.
4. Vahevara sees salvestame päringu ID AsyncLocalStorage'i, kasutades asyncLocalStorage.getStore().set('requestId', requestId).
5. Määratleme asünkroonse funktsiooni doSomethingAsync(), mis simuleerib asünkroonset operatsiooni ja hangib päringu ID AsyncLocalStorage'ist.
6. Marsruudi käsitlejas hangime päringu ID AsyncLocalStorage'ist ja lisame selle vastusesse.

Kui käivitate selle rakenduse ja saadate päringu aadressile http://localhost:3000, näete päringu ID-d logituna nii marsruudi käsitlejas kui ka asünkroonses funktsioonis, mis näitab, et kontekst on korrektselt levitatud.

Selgitus

• AsyncLocalStorage'i instants: Loome AsyncLocalStorage'i instantsi, mis hoiab meie konteksti andmeid.
• Vahevara: Vahevara püüab kinni iga sissetuleva päringu. See genereerib UUID ja kasutab seejärel asyncLocalStorage.run, et käivitada ülejäänud päringu käsitlemise ahel *selle* salvestusruumi kontekstis. See on ülioluline; see tagab, et kõik allavoolu komponendid pääsevad salvestatud andmetele juurde.
• asyncLocalStorage.run(new Map(), ...): See meetod võtab kaks argumenti: uue, tühja Map'i (võite kasutada ka teisi andmestruktuure, kui see teie konteksti jaoks sobib) ja tagasikutsefunktsiooni (callback). Tagasikutsefunktsioon sisaldab koodi, mis peaks töötama asünkroonses kontekstis. Kõik selles tagasikutses algatatud asünkroonsed operatsioonid pärivad automaatselt Map'i salvestatud andmed.
• asyncLocalStorage.getStore(): See tagastab Map'i, mis edastati meetodile asyncLocalStorage.run. Me kasutame seda päringu ID salvestamiseks ja hankimiseks. Kui run'i pole kutsutud, tagastab see undefined, mistõttu on oluline kutsuda run vahevara sees.
• Asünkroonne funktsioon: Funktsioon doSomethingAsync simuleerib asünkroonset operatsiooni. Oluline on see, et kuigi see on asünkroonne (kasutades setTimeout), on tal endiselt juurdepääs päringu ID-le, kuna see töötab asyncLocalStorage.run'i poolt loodud kontekstis.

Täpsem kasutus: kombineerimine logimisteekidega

AsyncLocalStorage'i integreerimine logimisteekidega (nagu Winston või Pino) võib oluliselt parandada teie rakenduste jälgitavust. Süstides konteksti andmeid (nt päringu ID, kasutaja ID) logisõnumitesse, saate hõlpsasti korreleerida logisid ja jälitada päringuid üle erinevate komponentide.

Näide Winstoniga

            // logger.js
const winston = require('winston');
const { AsyncLocalStorage } = require('async_hooks');

const asyncLocalStorage = new AsyncLocalStorage();

const logger = winston.createLogger({
  level: 'info',
  format: winston.format.combine(
    winston.format.timestamp(),
    winston.format.printf(({ timestamp, level, message }) => {
      const requestId = asyncLocalStorage.getStore() ? asyncLocalStorage.getStore().get('requestId') : 'N/A';
      return `${timestamp} [${level}] [${requestId}] ${message}`;
    })
  ),
  transports: [
    new winston.transports.Console()
  ]
});

module.exports = {
  logger,
  asyncLocalStorage
};

            

              
                Copy
              
            
          

            // app.js (muudetud)
const express = require('express');
const { v4: uuidv4 } = require('uuid');
const { logger, asyncLocalStorage } = require('./logger');

const app = express();
const port = 3000;

app.use((req, res, next) => {
  const requestId = uuidv4();
  asyncLocalStorage.run(new Map(), () => {
    asyncLocalStorage.getStore().set('requestId', requestId);
    logger.info(`Incoming request: ${req.url}`); // Logime sissetuleva päringu
    next();
  });
});

async function doSomethingAsync() {
  return new Promise(resolve => {
    setTimeout(() => {
      logger.info('Doing something async...');
      resolve();
    }, 50);
  });
}

app.get('/', async (req, res) => {
  logger.info('Handling request...');
  await doSomethingAsync();
  res.send('Hello World!');
});

app.listen(port, () => {
  logger.info(`App listening at http://localhost:${port}`);
});

            

              
                Copy
              
            
          

Selles näites:

• Loome Winstoni logija instantsi ja seadistame selle nii, et see lisaks igasse logisõnumisse päringu ID AsyncLocalStorage'ist. Oluline osa on winston.format.printf, mis hangib päringu ID (kui see on saadaval) AsyncLocalStorage'ist. Kontrollime, kas asyncLocalStorage.getStore() eksisteerib, et vältida vigu logimisel väljaspool päringu konteksti.
• Uuendame vahevara, et see logiks sissetuleva päringu URL-i.
• Uuendame marsruudi käsitlejat ja asünkroonset funktsiooni, et need logiksid sõnumeid, kasutades seadistatud logijat.

Nüüd sisaldavad kõik logisõnumid päringu ID-d, mis teeb päringute jälgimise ja logide korreleerimise lihtsamaks.

Alternatiivsed lähenemised: cls-hooked ja Async Hooks

Enne kui AsyncLocalStorage sai kättesaadavaks, kasutati asünkroonse konteksti levitamiseks tavaliselt teeke nagu cls-hooked. cls-hooked kasutab sarnase funktsionaalsuse saavutamiseks Async Hooks'e (madalama taseme Node.js API). Kuigi cls-hooked on endiselt laialdaselt kasutusel, eelistatakse üldiselt AsyncLocalStorage'i selle sisseehitatud olemuse ja parema jõudluse tõttu.

Async Hooks (async_hooks)

Async Hooks pakub madalama taseme API-d asünkroonsete operatsioonide elutsükli jälgimiseks. Kuigi AsyncLocalStorage on ehitatud Async Hooks'ide peale, on Async Hooks'ide otsene kasutamine sageli keerulisem ja vähem jõudlusoptimaalne. Async Hooks sobib paremini väga spetsiifiliste, täiustatud kasutusjuhtude jaoks, kus on vajalik peeneteraline kontroll asünkroonse elutsükli üle. Vältige Async Hooks'ide otsest kasutamist, kui see pole absoluutselt vajalik.

Miks eelistada AsyncLocalStorage'i cls-hooked'ile?

• Sisseehitatud: AsyncLocalStorage on osa Node.js tuumast, mis välistab vajaduse väliste sõltuvuste järele.
• Jõudlus: AsyncLocalStorage on oma optimeeritud implementatsiooni tõttu üldiselt jõudlusvõimelisem kui cls-hooked.
• Hooldus: Sisseehitatud moodulina hooldab AsyncLocalStorage'i aktiivselt Node.js tuumikmeeskond.

Kaalutlused ja piirangud

Kuigi AsyncLocalStorage on võimas tööriist, on oluline olla teadlik selle piirangutest:

• Konteksti piirid: AsyncLocalStorage levitab konteksti ainult sama täitmiskonteksti piires. Kui edastate andmeid erinevate protsesside või serverite vahel (nt sõnumijärjekordade või gRPC kaudu), peate ikkagi konteksti andmeid otseselt serialiseerima ja deserialiseerima.
• Mälulekked: AsyncLocalStorage'i ebaõige kasutamine võib potentsiaalselt põhjustada mälulekkeid, kui konteksti andmeid ei puhastata korralikult. Veenduge, et kasutate asyncLocalStorage.run() korrektselt ja vältige suurte andmemahtude salvestamist AsyncLocalStorage'i.
• Keerukus: Kuigi AsyncLocalStorage lihtsustab konteksti levitamist, võib see hoolimatu kasutamise korral lisada koodile ka keerukust. Veenduge, et teie meeskond mõistab, kuidas see töötab, ja järgib parimaid praktikaid.
• Ei asenda globaalseid muutujaid: AsyncLocalStorage *ei ole* globaalsete muutujate asendaja. See on spetsiaalselt loodud konteksti levitamiseks ühe päringu või tehingu piires. Selle liigne kasutamine võib viia tihedalt seotud koodini ja muuta testimise keerulisemaks.

AsyncLocalStorage'i kasutamise parimad praktikad

AsyncLocalStorage'i tõhusaks kasutamiseks kaaluge järgmisi parimaid praktikaid:

• Kasutage vahevara: Kasutage vahevara AsyncLocalStorage'i lähtestamiseks ja konteksti andmete salvestamiseks iga päringu alguses.
• Salvestage minimaalselt andmeid: Salvestage AsyncLocalStorage'i ainult hädavajalikke konteksti andmeid, et minimeerida mälu koormust. Vältige suurte objektide või tundliku teabe salvestamist.
• Vältige otsest juurdepääsu: Kapseldage juurdepääs AsyncLocalStorage'ile selgelt määratletud API-de taha, et vältida tihedat sidumist ja parandada koodi hooldatavust. Looge abifunktsioone või klasse konteksti andmete haldamiseks.
• Kaaluge veakäsitlust: Rakendage veakäsitlust, et sujuvalt hallata juhtumeid, kus AsyncLocalStorage pole korralikult lähtestatud.
• Testige põhjalikult: Kirjutage ühiku- ja integratsiooniteste, et tagada konteksti levitamise ootuspärane toimimine.
• Dokumenteerige kasutust: Dokumenteerige selgelt, kuidas AsyncLocalStorage'i teie rakenduses kasutatakse, et aidata teistel arendajatel mõista konteksti levitamise mehhanismi.

Integreerimine OpenTelemetry'ga

OpenTelemetry on avatud lähtekoodiga jälgitavuse raamistik, mis pakub API-sid, SDK-sid ja tööriistu telemeetriaandmete (nt jäljed, mõõdikud, logid) kogumiseks ja eksportimiseks. AsyncLocalStorage'i saab sujuvalt integreerida OpenTelemetry'ga, et automaatselt levitada jäljekonteksti üle asünkroonsete operatsioonide.

OpenTelemetry tugineb tugevalt konteksti levitamisele, et korreleerida jälgi erinevate teenuste vahel. Kasutades AsyncLocalStorage'i, saate tagada, et jäljekontekst levib teie Node.js rakenduses korrektselt, võimaldades teil luua tervikliku hajutatud jälgimissüsteemi.

Paljud OpenTelemetry SDK-d kasutavad konteksti levitamiseks automaatselt AsyncLocalStorage'i (või cls-hooked'i, kui AsyncLocalStorage pole saadaval). Kontrollige konkreetsete üksikasjade saamiseks oma valitud OpenTelemetry SDK dokumentatsiooni.

Kokkuvõte

AsyncLocalStorage on väärtuslik tööriist asünkroonse konteksti levitamise haldamiseks serveripoolsetes JavaScripti rakendustes. Kasutades seda päringute jälgimiseks, autentimiseks, logimiseks ja muudeks kasutusjuhtudeks, saate ehitada robustsemaid, jälgitavamaid ja hooldatavamaid rakendusi. Kuigi on olemas alternatiive nagu cls-hooked ja Async Hooks, on AsyncLocalStorage oma sisseehitatud olemuse, jõudluse ja kasutuslihtsuse tõttu üldiselt eelistatud valik. Pidage meeles järgida parimaid praktikaid ja olla teadlik selle piirangutest, et selle võimekust tõhusalt ära kasutada. Võime jälgida päringuid ja korreleerida sündmusi üle asünkroonsete operatsioonide on ülioluline skaleeritavate ja usaldusväärsete süsteemide ehitamisel, eriti mikroteenuste arhitektuurides ja keerukates hajutatud keskkondades. AsyncLocalStorage'i kasutamine aitab seda eesmärki saavutada, viies lõppkokkuvõttes parema silumise, jõudluse monitooringu ja üldise rakenduse terviklikkuseni.