JavaScript'i asünkroonsed kontekstimuutujad: sügavuti päringute jälgimisest

Asünkroonne programmeerimine on kaasaegse JavaScripti arenduse alustala, eriti keskkondades nagu Node.js. Olekute ja konteksti haldamine asünkroonsete operatsioonide vahel võib aga olla keeruline. Siin tulevadki mängu asünkroonsed kontekstimuutujad (ACV). See artikkel pakub põhjalikku juhendit asünkroonsete kontekstimuutujate mõistmiseks ja rakendamiseks robustseks päringute jälgimiseks ning paremaks diagnostikaks.

Mis on asünkroonsed kontekstimuutujad?

Asünkroonsed kontekstimuutujad, tuntud ka kui AsyncLocalStorage Node.js-is, pakuvad mehhanismi andmete salvestamiseks ja neile juurdepääsuks, mis on lokaalsed praegusele asünkroonsele täitmiskontekstile. Mõelge sellest kui lõimepõhisest salvestusest (thread-local storage) teistes keeltes, kuid kohandatud JavaScripti ühelõimelisele, sündmuspõhisele olemusele. See võimaldab teil seostada andmeid asünkroonse operatsiooniga ja pääseda neile järjepidevalt juurde kogu selle operatsiooni elutsükli vältel, olenemata sellest, kui palju asünkroonseid kutseid tehakse.

Traditsioonilised lähenemised päringute jälgimisele, nagu andmete edastamine funktsiooni argumentide kaudu, võivad muutuda tülikaks ja vigaderohkeks, kui rakenduse keerukus kasvab. Asünkroonsed kontekstimuutujad pakuvad puhtamat ja paremini hooldatavat lahendust.

Miks kasutada asünkroonseid kontekstimuutujaid päringute jälgimiseks?

Päringute jälgimine on ülioluline mitmel põhjusel:

• Silumine: Kui tekib viga, peate mõistma konteksti, milles see juhtus. Päringu ID-d, kasutaja ID-d ja muud asjakohased andmed aitavad probleemi allika kindlaks teha.
• Logimine: Logisõnumite rikastamine päringuspetsiifilise teabega muudab päringu täitmise voo jälgimise ja jõudluse kitsaskohtade tuvastamise lihtsamaks.
• Jõudluse monitooring: Päringute kestuste ja ressursside kasutamise jälgimine aitab tuvastada aeglaseid lõpp-punkte ja optimeerida rakenduse jõudlust.
• Turvaaudit: Kasutajate tegevuste ja nendega seotud andmete logimine võib pakkuda väärtuslikku teavet turvaauditite ja vastavuse tagamise eesmärgil.

Asünkroonsed kontekstimuutujad lihtsustavad päringute jälgimist, pakkudes keskset ja kergesti ligipääsetavat hoidlat päringuspetsiifiliste andmete jaoks. See välistab vajaduse käsitsi kontekstiandmeid läbi mitmete funktsioonikutsete ja asünkroonsete operatsioonide edastada.

Asünkroonsete kontekstimuutujate rakendamine Node.js-is

Node.js pakub moodulit async_hooks, mis sisaldab klassi AsyncLocalStorage asünkroonse konteksti haldamiseks. Siin on lihtne näide:

Näide: elementaarne päringute jälgimine AsyncLocalStorage abil

Kõigepealt importige vajalikud moodulid:

            const { AsyncLocalStorage } = require('async_hooks');
const http = require('http');

            

              
                Copy
              
            
          

Looge AsyncLocalStorage'i eksemplar:

            const asyncLocalStorage = new AsyncLocalStorage();

            

              
                Copy
              
            
          

Looge HTTP-server, mis kasutab AsyncLocalStorage'i päringu ID salvestamiseks ja hankimiseks:

            const server = http.createServer((req, res) => {
  const requestId = Math.random().toString(36).substring(2, 15);

  asyncLocalStorage.run(new Map(), () => {
    asyncLocalStorage.getStore().set('requestId', requestId);

    console.log(`Request ID: ${asyncLocalStorage.getStore().get('requestId')}`);

    setTimeout(() => {
      console.log(`Request ID inside timeout: ${asyncLocalStorage.getStore().get('requestId')}`);
      res.end('Hello, world!');
    }, 100);
  });
});

            

              
                Copy
              
            
          

Käivitage server:

            server.listen(3000, () => {
  console.log('Server listening on port 3000');
});

            

              
                Copy
              
            
          

Selles näites loob asyncLocalStorage.run() uue asünkroonse konteksti. Selles kontekstis seadistame requestId. Funktsioon setTimeout, mis täidetakse asünkroonselt, pääseb endiselt ligi requestId-le, kuna see asub samas asünkroonses kontekstis.

Selgitus

• AsyncLocalStorage: Pakub API-d asünkroonse konteksti haldamiseks.
• asyncLocalStorage.run(store, callback): Käivitab callback-funktsiooni uues asünkroonses kontekstis. Argument store on konteksti algväärtus (nt Map või objekt).
• asyncLocalStorage.getStore(): Tagastab praeguse asünkroonse konteksti hoidla.

Täpsemad päringute jälgimise stsenaariumid

Lihtne näide demonstreerib põhiprintsiipe. Siin on mõned täpsemad stsenaariumid:

Stsenaarium 1: integreerimine andmebaasiga

Saate kasutada asünkroonseid kontekstimuutujaid, et automaatselt lisada päringu ID-d andmebaasipäringutele. See on eriti kasulik andmebaasi interaktsioonide auditeerimiseks ja silumiseks.

            const { AsyncLocalStorage } = require('async_hooks');
const http = require('http');
const { Pool } = require('pg'); // Assuming PostgreSQL

const asyncLocalStorage = new AsyncLocalStorage();

const pool = new Pool({
  user: 'your_user',
  host: 'your_host',
  database: 'your_database',
  password: 'your_password',
  port: 5432,
});

// Function to execute a query with request ID
async function executeQuery(queryText, values = []) {
  const requestId = asyncLocalStorage.getStore()?.get('requestId') || 'unknown';
  const enrichedQueryText = `/* requestId: ${requestId} */ ${queryText}`;
  try {
     const res = await pool.query(enrichedQueryText, values);
     return res;
  } catch (err) {
     console.error("Error executing query:", err);
     throw err;
  }

}

const server = http.createServer(async (req, res) => {
  const requestId = Math.random().toString(36).substring(2, 15);

  asyncLocalStorage.run(new Map(), async () => {
    asyncLocalStorage.getStore().set('requestId', requestId);

    console.log(`Request ID: ${asyncLocalStorage.getStore().get('requestId')}`);

    try {
      // Example: Insert data into a table
      const result = await executeQuery('SELECT NOW()');
      console.log("Query result:", result.rows);
      res.end('Hello, database!');
    } catch (error) {
      console.error("Request failed:", error);
      res.statusCode = 500;
      res.end('Internal Server Error');
    }

  });
});

server.listen(3000, () => {
  console.log('Server listening on port 3000');
});

            

              
                Copy
              
            
          

Selles näites hangib funktsioon executeQuery päringu ID AsyncLocalStorage'ist ja lisab selle kommentaarina SQL-päringusse. See võimaldab teil andmebaasipäringuid hõlpsasti konkreetsete päringutega seostada.

Stsenaarium 2: hajutatud jälgimine (Distributed Tracing)

Keeruliste rakenduste puhul, mis koosnevad mitmest mikroteenusest, saate kasutada asünkroonseid kontekstimuutujaid jälgimisteabe levitamiseks teenuste piiride üleselt. See võimaldab täielikku päringute jälgimist (end-to-end), mis on oluline jõudluse kitsaskohtade tuvastamiseks ja hajutatud süsteemide silumiseks.

See hõlmab tavaliselt unikaalse jälgimis-ID (trace ID) genereerimist päringu alguses ja selle edastamist kõikidele järgnevatele teenustele. Seda saab teha, lisades jälgimis-ID HTTP päistesse.

            const { AsyncLocalStorage } = require('async_hooks');
const http = require('http');
const https = require('https');

const asyncLocalStorage = new AsyncLocalStorage();

const server = http.createServer((req, res) => {
  const traceId = Math.random().toString(36).substring(2, 15);

  asyncLocalStorage.run(new Map(), () => {
    asyncLocalStorage.getStore().set('traceId', traceId);

    console.log(`Trace ID: ${asyncLocalStorage.getStore().get('traceId')}`);

    // Make a request to another service
    makeRequestToAnotherService(traceId)
      .then(data => {
        res.end(`Response from other service: ${data}`);
      })
      .catch(err => {
        console.error('Error making request:', err);
        res.statusCode = 500;
        res.end('Error from upstream service');
      });

  });
});

async function makeRequestToAnotherService(traceId) {
  return new Promise((resolve, reject) => {
    const options = {
      hostname: 'example.com',
      port: 443,
      path: '/',
      method: 'GET',
      headers: {
        'X-Trace-ID': traceId, // Propagate trace ID in HTTP header
      },
    };

    const req = https.request(options, (res) => {
      let data = '';

      res.on('data', (chunk) => {
        data += chunk;
      });

      res.on('end', () => {
        resolve(data);
      });
    });

    req.on('error', (error) => {
      reject(error);
    });

    req.end();
  });
}

server.listen(3000, () => {
  console.log('Server listening on port 3000');
});

            

              
                Copy
              
            
          

Vastuvõttev teenus saab seejärel jälgimis-ID HTTP päisest eraldada ja salvestada selle oma AsyncLocalStorage'i. See loob jälgimis-ID-de ahela, mis ulatub üle mitme teenuse, võimaldades täielikku päringute jälgimist.

Stsenaarium 3: logide korrelatsioon

Järjepidev logimine koos päringuspetsiifilise teabega võimaldab logisid korreleerida mitme teenuse ja komponendi vahel. See muudab probleemide diagnoosimise ja päringute voo jälgimise süsteemis lihtsamaks. Teeke nagu Winston ja Bunyan saab integreerida, et automaatselt lisada AsyncLocalStorage andmed logisõnumitesse.

Siin on, kuidas konfigureerida Winston automaatseks logide korrelatsiooniks:

            const { AsyncLocalStorage } = require('async_hooks');
const http = require('http');
const winston = require('winston');

const asyncLocalStorage = new AsyncLocalStorage();

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

const server = http.createServer((req, res) => {
  const requestId = Math.random().toString(36).substring(2, 15);

  asyncLocalStorage.run(new Map(), () => {
    asyncLocalStorage.getStore().set('requestId', requestId);

    logger.info('Request received');

    setTimeout(() => {
      logger.info('Processing request...');
      res.end('Hello, logging!');
    }, 100);
  });
});

server.listen(3000, () => {
  console.log('Server listening on port 3000');
});

            

              
                Copy
              
            
          

Konfigureerides Winstoni logija nii, et see lisaks päringu ID AsyncLocalStorage'ist, märgitakse kõik päringu kontekstis olevad logisõnumid automaatselt päringu ID-ga.

Asünkroonsete kontekstimuutujate kasutamise parimad tavad

• Initsialiseerige AsyncLocalStorage varakult: Looge ja initsialiseerige oma AsyncLocalStorage'i eksemplar oma rakenduse elutsükli võimalikult varajases etapis. See tagab, et see on teie rakenduses kogu aeg saadaval.
• Kasutage järjepidevat nimekonventsiooni: Kehtestage oma kontekstimuutujatele järjepidev nimekonventsioon. See muudab teie koodi mõistmise ja hooldamise lihtsamaks. Näiteks võite kõik kontekstimuutujate nimed alustada eesliitega acv_.
• Minimeerige kontekstiandmeid: Salvestage asünkroonsesse konteksti ainult olulised andmed. Suured kontekstiobjektid võivad jõudlust mõjutada. Kaaluge objektide endi asemel viidete salvestamist teistele objektidele.
• Käsitsege vigu hoolikalt: Veenduge, et teie veakäsitlusloogika puhastab asünkroonse konteksti korralikult. Püüdmata erandid võivad jätta konteksti ebajärjepidevasse olekusse.
• Kaaluge jõudlusmõjusid: Kuigi AsyncLocalStorage on üldiselt hea jõudlusega, võib liigne kasutamine või suured kontekstiobjektid jõudlust mõjutada. Mõõtke oma rakenduse jõudlust pärast AsyncLocalStorage'i rakendamist.
• Kasutage teekides ettevaatlikult: Vältige AsyncLocalStorage'i kasutamist teekides, mis on mõeldud teistele tarbimiseks, kuna see võib põhjustada ootamatut käitumist ja konflikte tarbijarakenduse enda AsyncLocalStorage'i kasutusega.

Alternatiivid asünkroonsetele kontekstimuutujatele

Kuigi asünkroonsed kontekstimuutujad pakuvad võimsat lahendust päringute jälgimiseks, on olemas ka alternatiivseid lähenemisviise:

• Käsitsi konteksti edastamine: Kontekstiandmete edastamine funktsiooni argumentidena. See lähenemine on lihtne väikeste rakenduste puhul, kuid muutub keerukuse kasvades tülikaks ja vigaderohkeks.
• Vahevara (Middleware): Vahevara kasutamine kontekstiandmete süstimiseks päringuobjektidesse. See lähenemine on levinud veebiraamistikes nagu Express.js.
• Konteksti edastamise teegid: Teegid, mis pakuvad kõrgema taseme abstraktsioone konteksti edastamiseks. Need teegid võivad lihtsustada keeruliste jälgimisstsenaariumide rakendamist.

Lähenemisviisi valik sõltub teie rakenduse konkreetsetest nõuetest. Asünkroonsed kontekstimuutujad sobivad eriti hästi keeruliste asünkroonsete töövoogude jaoks, kus käsitsi konteksti edastamist on raske hallata.

Kokkuvõte

Asünkroonsed kontekstimuutujad pakuvad võimsat ja elegantset lahendust oleku ja konteksti haldamiseks asünkroonsetes JavaScripti rakendustes. Kasutades asünkroonseid kontekstimuutujaid päringute jälgimiseks, saate oluliselt parandada oma rakenduste silutavust, hooldatavust ja jõudlust. Alates lihtsast päringu ID jälgimisest kuni täiustatud hajutatud jälgimise ja logide korrelatsioonini annab AsyncLocalStorage teile võimaluse ehitada robustsemaid ja paremini jälgitavaid süsteeme. Nende tehnikate mõistmine ja rakendamine on oluline igale arendajale, kes töötab asünkroonse JavaScriptiga, eriti keerulistes serveripoolsetes keskkondades.