Asynkrona kontextvariabler i JavaScript: En djupdykning i spårning av förfrågningar

Asynkron programmering är grundläggande för modern JavaScript-utveckling, särskilt i miljöer som Node.js. Att hantera tillstånd och kontext över asynkrona operationer kan dock vara utmanande. Det är här asynkrona kontextvariabler (ACV) kommer in i bilden. Den här artikeln ger en omfattande guide för att förstå och implementera asynkrona kontextvariabler för robust spårning av förfrågningar och förbättrad diagnostik.

Vad är asynkrona kontextvariabler?

Asynkrona kontextvariabler, även kända som AsyncLocalStorage i Node.js, tillhandahåller en mekanism för att lagra och komma åt data som är lokal för den aktuella asynkrona exekveringskontexten. Tänk på det som trådlokal lagring i andra språk, men anpassat för JavaScripts entrådiga, händelsedrivna natur. Detta gör att du kan associera data med en asynkron operation och komma åt den konsekvent under hela operationens livscykel, oavsett hur många asynkrona anrop som görs.

Traditionella metoder för spårning av förfrågningar, som att skicka data via funktionsargument, kan bli besvärliga och felbenägna när applikationens komplexitet ökar. Asynkrona kontextvariabler erbjuder en renare och mer underhållbar lösning.

Varför använda asynkrona kontextvariabler för spårning av förfrågningar?

Spårning av förfrågningar är avgörande av flera anledningar:

• Felsökning: När ett fel inträffar behöver du förstå i vilken kontext det hände. Förfrågnings-ID, användar-ID och annan relevant data kan hjälpa till att lokalisera källan till problemet.
• Loggning: Att berika loggmeddelanden med förfrågningsspecifik information gör det lättare att spåra exekveringsflödet för en förfrågan och identifiera prestandaflaskhalsar.
• Prestandaövervakning: Att spåra varaktigheten på förfrågningar och resursanvändning kan hjälpa till att identifiera långsamma endpoints och optimera applikationens prestanda.
• Säkerhetsgranskning: Att logga användaråtgärder och tillhörande data kan ge värdefulla insikter för säkerhetsrevisioner och regelefterlevnad.

Asynkrona kontextvariabler förenklar spårning av förfrågningar genom att tillhandahålla ett centralt, lättillgängligt arkiv för förfrågningsspecifik data. Detta eliminerar behovet av att manuellt propagera kontextdata genom flera funktionsanrop och asynkrona operationer.

Implementera asynkrona kontextvariabler i Node.js

Node.js tillhandahåller modulen async_hooks, som inkluderar klassen AsyncLocalStorage, för att hantera asynkron kontext. Här är ett grundläggande exempel:

Exempel: Grundläggande spårning av förfrågningar med AsyncLocalStorage

Importera först de nödvändiga modulerna:

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

            

              
                Copy
              
            
          

Skapa en instans av AsyncLocalStorage:

            const asyncLocalStorage = new AsyncLocalStorage();

            

              
                Copy
              
            
          

Skapa en HTTP-server som använder AsyncLocalStorage för att lagra och hämta ett förfrågnings-ID:

            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
              
            
          

Starta servern:

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

            

              
                Copy
              
            
          

I det här exemplet skapar asyncLocalStorage.run() en ny asynkron kontext. Inom denna kontext sätter vi requestId. Funktionen setTimeout, som exekveras asynkront, kan fortfarande komma åt requestId eftersom den befinner sig inom samma asynkrona kontext.

Förklaring

• AsyncLocalStorage: Tillhandahåller API:et för att hantera asynkron kontext.
• asyncLocalStorage.run(store, callback): Exekverar callback-funktionen inom en ny asynkron kontext. Argumentet store är ett initialt värde för kontexten (t.ex. en Map eller ett objekt).
• asyncLocalStorage.getStore(): Returnerar den aktuella asynkrona kontextens lagring.

Avancerade scenarier för spårning av förfrågningar

Det grundläggande exemplet demonstrerar de fundamentala principerna. Här är mer avancerade scenarier:

Scenario 1: Integration med en databas

Du kan använda asynkrona kontextvariabler för att automatiskt inkludera förfrågnings-ID i databasfrågor. Detta är särskilt användbart för att granska och felsöka databasinteraktioner.

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

const asyncLocalStorage = new AsyncLocalStorage();

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

// Funktion för att exekvera en fråga med förfrågnings-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 {
      // Exempel: Infoga data i en tabell
      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
              
            
          

I det här exemplet hämtar funktionen executeQuery förfrågnings-ID:t från AsyncLocalStorage och inkluderar det som en kommentar i SQL-frågan. Detta gör att du enkelt kan spåra databasfrågor tillbaka till specifika förfrågningar.

Scenario 2: Distribuerad spårning

För komplexa applikationer med flera mikrotjänster kan du använda asynkrona kontextvariabler för att propagera spårningsinformation över tjänstegränser. Detta möjliggör end-to-end-spårning av förfrågningar, vilket är avgörande för att identifiera prestandaflaskhalsar och felsöka distribuerade system.

Detta involverar vanligtvis att generera ett unikt spårnings-ID i början av en förfrågan och propagera det till alla nedströmstjänster. Detta kan göras genom att inkludera spårnings-ID:t i HTTP-headers.

            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')}`);

    // Gör en förfrågan till en annan tjänst
    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, // Propagera spårnings-ID i HTTP-huvudet
      },
    };

    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
              
            
          

Den mottagande tjänsten kan sedan extrahera spårnings-ID:t från HTTP-huvudet och lagra det i sin egen AsyncLocalStorage. Detta skapar en kedja av spårnings-ID som sträcker sig över flera tjänster, vilket möjliggör end-to-end-spårning av förfrågningar.

Scenario 3: Loggkorrelation

Konsekvent loggning med förfrågningsspecifik information gör det möjligt att korrelera loggar över flera tjänster och komponenter. Detta gör det lättare att diagnostisera problem och spåra flödet av förfrågningar genom systemet. Bibliotek som Winston och Bunyan kan integreras för att automatiskt inkludera data från AsyncLocalStorage i loggmeddelanden.

Så här konfigurerar du Winston för automatisk loggkorrelation:

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

const asyncLocalStorage = new AsyncLocalStorage();

// Konfigurera Winston-loggaren
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
              
            
          

Genom att konfigurera Winston-loggaren att inkludera förfrågnings-ID:t från AsyncLocalStorage kommer alla loggmeddelanden inom förfrågningskontexten automatiskt att taggas med förfrågnings-ID:t.

Bästa praxis för att använda asynkrona kontextvariabler

• Initiera AsyncLocalStorage tidigt: Skapa och initiera din AsyncLocalStorage-instans så tidigt som möjligt i din applikations livscykel. Detta säkerställer att den är tillgänglig i hela din applikation.
• Använd en konsekvent namngivningskonvention: Etablera en konsekvent namngivningskonvention för dina kontextvariabler. Detta gör det lättare att förstå och underhålla din kod. Till exempel kan du prefixa alla kontextvariabelnamn med acv_.
• Minimera kontextdata: Lagra endast nödvändig data i den asynkrona kontexten. Stora kontextobjekt kan påverka prestandan. Överväg att lagra referenser till andra objekt istället för objekten själva.
• Hantera fel noggrant: Se till att din felhanteringslogik städar upp den asynkrona kontexten korrekt. Ohanterade undantag kan lämna kontexten i ett inkonsekvent tillstånd.
• Tänk på prestandakonsekvenser: Även om AsyncLocalStorage generellt sett har bra prestanda, kan överdriven användning eller stora kontextobjekt påverka prestandan. Mät prestandan för din applikation efter att ha implementerat AsyncLocalStorage.
• Använd med försiktighet i bibliotek: Undvik att använda AsyncLocalStorage i bibliotek som är avsedda att användas av andra, eftersom det kan leda till oväntat beteende och konflikter med konsumentapplikationens egen användning av AsyncLocalStorage.

Alternativ till asynkrona kontextvariabler

Även om asynkrona kontextvariabler erbjuder en kraftfull lösning för spårning av förfrågningar, finns det alternativa metoder:

• Manuell kontextpropagering: Att skicka kontextdata som funktionsargument. Denna metod är enkel för små applikationer, men blir besvärlig och felbenägen när komplexiteten ökar.
• Middleware: Att använda middleware för att injicera kontextdata i förfrågningsobjekt. Denna metod är vanlig i webbramverk som Express.js.
• Bibliotek för kontextpropagering: Bibliotek som tillhandahåller abstraktioner på högre nivå för kontextpropagering. Dessa bibliotek kan förenkla implementeringen av komplexa spårningsscenarier.

Valet av metod beror på de specifika kraven för din applikation. Asynkrona kontextvariabler är särskilt väl lämpade för komplexa asynkrona arbetsflöden där manuell kontextpropagering blir svår att hantera.

Sammanfattning

Asynkrona kontextvariabler erbjuder en kraftfull och elegant lösning för att hantera tillstånd och kontext i asynkrona JavaScript-applikationer. Genom att använda asynkrona kontextvariabler för spårning av förfrågningar kan du avsevärt förbättra felsökningsmöjligheterna, underhållbarheten och prestandan för dina applikationer. Från grundläggande spårning av förfrågnings-ID till avancerad distribuerad spårning och loggkorrelation, ger AsyncLocalStorage dig kraften att bygga mer robusta och observerbara system. Att förstå och implementera dessa tekniker är avgörande för alla utvecklare som arbetar med asynkron JavaScript, särskilt i komplexa servermiljöer.