ஜாவாஸ்கிரிப்ட் அசிங்க் கான்டெக்ஸ்ட் வேரியபிள்கள்: கோரிக்கை கண்காணிப்பு பற்றிய ஒரு ஆழமான பார்வை

ஒத்திசைவற்ற நிரலாக்கம் நவீன ஜாவாஸ்கிரிப்ட் வளர்ச்சிக்கு, குறிப்பாக Node.js போன்ற சூழல்களில் அடிப்படையானது. இருப்பினும், ஒத்திசைவற்ற செயல்பாடுகள் முழுவதும் நிலை மற்றும் சூழலை நிர்வகிப்பது சவாலானதாக இருக்கும். இங்குதான் அசிங்க் கான்டெக்ஸ்ட் வேரியபிள்கள் (ACV) உதவுகின்றன. இந்த கட்டுரை, வலுவான கோரிக்கை கண்காணிப்பு மற்றும் மேம்பட்ட கண்டறிதலுக்காக அசிங்க் கான்டெக்ஸ்ட் வேரியபிள்களைப் புரிந்துகொள்வதற்கும் செயல்படுத்துவதற்கும் ஒரு விரிவான வழிகாட்டியை வழங்குகிறது.

அசிங்க் கான்டெக்ஸ்ட் வேரியபிள்கள் என்றால் என்ன?

அசிங்க் கான்டெக்ஸ்ட் வேரியபிள்கள், Node.js இல் AsyncLocalStorage என்றும் அழைக்கப்படுகிறது, இது தற்போதைய ஒத்திசைவற்ற செயல்பாட்டு சூழலுக்கு உள்ளூர் தரவை சேமிப்பதற்கும் அணுகுவதற்கும் ஒரு வழிமுறையை வழங்குகிறது. இதை மற்ற மொழிகளில் உள்ள த்ரெட்-லோக்கல் ஸ்டோரேஜ் போல நினைத்துப் பாருங்கள், ஆனால் ஜாவாஸ்கிரிப்டின் ஒற்றை-திரிக்கப்பட்ட, நிகழ்வு-சார்ந்த தன்மைக்கு ஏற்றவாறு இது மாற்றியமைக்கப்பட்டுள்ளது. இது ஒரு ஒத்திசைவற்ற செயல்பாட்டுடன் தரவை இணைக்கவும், அந்த செயல்பாட்டின் முழு வாழ்க்கைச் சுழற்சியிலும் அதை சீராக அணுகவும் உங்களை அனுமதிக்கிறது, எத்தனை ஒத்திசைவற்ற அழைப்புகள் செய்யப்பட்டாலும் பரவாயில்லை.

செயல்பாட்டு வாதங்கள் மூலம் தரவைக் கடத்துவது போன்ற கோரிக்கை கண்காணிப்புக்கான பாரம்பரிய அணுகுமுறைகள், பயன்பாட்டின் சிக்கல் அதிகரிக்கும்போது சிரமமானதாகவும் பிழை ஏற்பட வாய்ப்புள்ளதாகவும் மாறும். அசிங்க் கான்டெக்ஸ்ட் வேரியபிள்கள் ஒரு சுத்தமான, மேலும் பராமரிக்கக்கூடிய தீர்வை வழங்குகின்றன.

கோரிக்கை கண்காணிப்பிற்கு அசிங்க் கான்டெக்ஸ்ட் வேரியபிள்களை ஏன் பயன்படுத்த வேண்டும்?

கோரிக்கை கண்காணிப்பு பல காரணங்களுக்காக முக்கியமானது:

• பிழைத்திருத்தம்: ஒரு பிழை ஏற்படும்போது, அது எந்த சூழலில் நடந்தது என்பதை நீங்கள் புரிந்து கொள்ள வேண்டும். கோரிக்கை ஐடிகள், பயனர் ஐடிகள் மற்றும் பிற தொடர்புடைய தரவுகள் சிக்கலின் மூலத்தைக் கண்டறிய உதவும்.
• பதிவுசெய்தல்: கோரிக்கை-குறிப்பிட்ட தகவல்களுடன் பதிவு செய்திகளை செறிவூட்டுவது, ஒரு கோரிக்கையின் செயல்பாட்டு ஓட்டத்தைக் கண்டறிவதையும் செயல்திறன் தடைகளைக் கண்டறிவதையும் எளிதாக்குகிறது.
• செயல்திறன் கண்காணிப்பு: கோரிக்கை காலங்கள் மற்றும் வளப் பயன்பாட்டைக் கண்காணிப்பது மெதுவான எண்ட்பாயிண்டுகளைக் கண்டறிந்து பயன்பாட்டு செயல்திறனை மேம்படுத்த உதவும்.
• பாதுகாப்பு தணிக்கை: பயனர் செயல்கள் மற்றும் அதனுடன் தொடர்புடைய தரவைப் பதிவு செய்வது பாதுகாப்பு தணிக்கைகள் மற்றும் இணக்க நோக்கங்களுக்காக மதிப்புமிக்க நுண்ணறிவுகளை வழங்க முடியும்.

அசிங்க் கான்டெக்ஸ்ட் வேரியபிள்கள் கோரிக்கை-குறிப்பிட்ட தரவுகளுக்கான ஒரு மையப்படுத்தப்பட்ட, உடனடியாக அணுகக்கூடிய களஞ்சியத்தை வழங்குவதன் மூலம் கோரிக்கை கண்காணிப்பை எளிதாக்குகின்றன. இது பல செயல்பாட்டு அழைப்புகள் மற்றும் ஒத்திசைவற்ற செயல்பாடுகள் மூலம் சூழல் தரவை கைமுறையாக பரப்புவதற்கான தேவையை நீக்குகிறது.

Node.js இல் அசிங்க் கான்டெக்ஸ்ட் வேரியபிள்களை செயல்படுத்துதல்

Node.js ஆனது async_hooks மாட்யூலை வழங்குகிறது, இது ஒத்திசைவற்ற சூழலை நிர்வகிப்பதற்காக AsyncLocalStorage வகுப்பை உள்ளடக்கியது. இதோ ஒரு அடிப்படை உதாரணம்:

உதாரணம்: AsyncLocalStorage உடன் அடிப்படை கோரிக்கை கண்காணிப்பு

முதலில், தேவையான மாட்யூல்களை இறக்குமதி செய்யவும்:

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

            

              
                Copy
              
            
          

AsyncLocalStorage-இன் ஒரு நிகழ்வை உருவாக்கவும்:

            const asyncLocalStorage = new AsyncLocalStorage();

            

              
                Copy
              
            
          

ஒரு கோரிக்கை ஐடியை சேமிக்கவும் மீட்டெடுக்கவும் AsyncLocalStorage-ஐ பயன்படுத்தும் ஒரு HTTP சேவையகத்தை உருவாக்கவும்:

            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
              
            
          

சேவையகத்தைத் தொடங்கவும்:

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

            

              
                Copy
              
            
          

இந்த எடுத்துக்காட்டில், asyncLocalStorage.run() ஒரு புதிய ஒத்திசைவற்ற சூழலை உருவாக்குகிறது. இந்த சூழலுக்குள், நாங்கள் requestId-ஐ அமைக்கிறோம். ஒத்திசைவற்ற முறையில் இயங்கும் setTimeout செயல்பாடு, அதே ஒத்திசைவற்ற சூழலுக்குள் இருப்பதால் requestId-ஐ அணுக முடிகிறது.

விளக்கம்

• AsyncLocalStorage: ஒத்திசைவற்ற சூழலை நிர்வகிப்பதற்கான API-ஐ வழங்குகிறது.
• asyncLocalStorage.run(store, callback): `callback` செயல்பாட்டை ஒரு புதிய ஒத்திசைவற்ற சூழலுக்குள் இயக்குகிறது. `store` ஆர்குமென்ட் என்பது சூழலுக்கான ஒரு ஆரம்ப மதிப்பாகும் (எ.கா., ஒரு `Map` அல்லது ஒரு ஆப்ஜெக்ட்).
• asyncLocalStorage.getStore(): தற்போதைய ஒத்திசைவற்ற சூழலின் ஸ்டோரை வழங்குகிறது.

மேம்பட்ட கோரிக்கை கண்காணிப்பு காட்சிகள்

அடிப்படை உதாரணம் அடிப்படைக் கொள்கைகளை விளக்குகிறது. இதோ மேலும் மேம்பட்ட காட்சிகள்:

காட்சி 1: தரவுத்தளத்துடன் ஒருங்கிணைத்தல்

தரவுத்தள வினவல்களில் கோரிக்கை ஐடிகளை தானாக சேர்க்க அசிங்க் கான்டெக்ஸ்ட் வேரியபிள்களைப் பயன்படுத்தலாம். இது தணிக்கை மற்றும் தரவுத்தள தொடர்புகளை பிழைத்திருத்தம் செய்வதற்கு மிகவும் பயனுள்ளதாக இருக்கும்.

            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
              
            
          

இந்த எடுத்துக்காட்டில், executeQuery செயல்பாடு AsyncLocalStorage-இலிருந்து கோரிக்கை ஐடியை மீட்டெடுத்து அதை SQL வினவலில் ஒரு கருத்தாகச் சேர்க்கிறது. இது தரவுத்தள வினவல்களை குறிப்பிட்ட கோரிக்கைகளுடன் எளிதாகக் கண்டறிய உங்களை அனுமதிக்கிறது.

காட்சி 2: பகிரப்பட்ட தடமறிதல் (Distributed Tracing)

பல மைக்ரோ சர்வீஸ்களைக் கொண்ட சிக்கலான பயன்பாடுகளுக்கு, சேவை எல்லைகள் முழுவதும் தடமறிதல் தகவல்களைப் பரப்புவதற்கு அசிங்க் கான்டெக்ஸ்ட் வேரியபிள்களைப் பயன்படுத்தலாம். இது இறுதி முதல் இறுதி வரையிலான கோரிக்கை தடமறிதலை செயல்படுத்துகிறது, இது செயல்திறன் தடைகளைக் கண்டறிவதற்கும் பகிரப்பட்ட அமைப்புகளை பிழைத்திருத்தம் செய்வதற்கும் அவசியமானது.

இது பொதுவாக ஒரு கோரிக்கையின் தொடக்கத்தில் ஒரு தனித்துவமான ட்ரேஸ் ஐடியை உருவாக்குவதையும், அதை அனைத்து கீழ்நிலை சேவைகளுக்கும் பரப்புவதையும் உள்ளடக்கியது. ட்ரேஸ் ஐடியை HTTP ஹெடர்களில் சேர்ப்பதன் மூலம் இதைச் செய்யலாம்.

            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
              
            
          

பெறும் சேவை பின்னர் HTTP ஹெடரிலிருந்து ட்ரேஸ் ஐடியை பிரித்தெடுத்து அதை தனது சொந்த AsyncLocalStorage-இல் சேமிக்க முடியும். இது பல சேவைகளை உள்ளடக்கிய ட்ரேஸ் ஐடிகளின் ஒரு சங்கிலியை உருவாக்குகிறது, இது இறுதி முதல் இறுதி வரையிலான கோரிக்கை தடமறிதலை செயல்படுத்துகிறது.

காட்சி 3: பதிவுசெய்தல் தொடர்புபடுத்துதல்

கோரிக்கை-குறிப்பிட்ட தகவல்களுடன் சீரான பதிவுசெய்தல், பல சேவைகள் மற்றும் கூறுகளில் உள்ள பதிவுகளை தொடர்புபடுத்த அனுமதிக்கிறது. இது சிக்கல்களைக் கண்டறிவதையும், கணினி மூலம் கோரிக்கைகளின் ஓட்டத்தைக் கண்டறிவதையும் எளிதாக்குகிறது. Winston மற்றும் Bunyan போன்ற நூலகங்களை AsyncLocalStorage தரவை தானாக பதிவு செய்திகளில் சேர்க்க ஒருங்கிணைக்கலாம்.

தானியங்கி பதிவுசெய்தல் தொடர்புபடுத்துதலுக்காக Winston-ஐ எவ்வாறு கட்டமைப்பது என்பது இங்கே:

            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
              
            
          

Winston லாகரை AsyncLocalStorage-இலிருந்து கோரிக்கை ஐடியைச் சேர்க்கும்படி கட்டமைப்பதன் மூலம், கோரிக்கை சூழலில் உள்ள அனைத்து பதிவு செய்திகளும் தானாகவே கோரிக்கை ஐடியுடன் குறியிடப்படும்.

அசிங்க் கான்டெக்ஸ்ட் வேரியபிள்களைப் பயன்படுத்துவதற்கான சிறந்த நடைமுறைகள்

• AsyncLocalStorage-ஐ முன்கூட்டியே துவக்கவும்: உங்கள் பயன்பாட்டின் வாழ்க்கைச் சுழற்சியில் முடிந்தவரை சீக்கிரம் உங்கள் AsyncLocalStorage நிகழ்வை உருவாக்கி துவக்கவும். இது உங்கள் பயன்பாடு முழுவதும் அது கிடைப்பதை உறுதி செய்கிறது.
• ஒரு சீரான பெயரிடும் மரபைப் பயன்படுத்தவும்: உங்கள் சூழல் மாறிகளுக்கான ஒரு சீரான பெயரிடும் மரபை நிறுவவும். இது உங்கள் குறியீட்டைப் புரிந்துகொள்வதையும் பராமரிப்பதையும் எளிதாக்குகிறது. எடுத்துக்காட்டாக, நீங்கள் அனைத்து சூழல் மாறி பெயர்களையும் acv_ உடன் முன்னொட்டாக வைக்கலாம்.
• சூழல் தரவைக் குறைக்கவும்: அசிங்க் கான்டெக்ஸில் அத்தியாவசிய தரவை மட்டும் சேமிக்கவும். பெரிய சூழல் ஆப்ஜெக்ட்கள் செயல்திறனை பாதிக்கலாம். ஆப்ஜெக்ட்களுக்குப் பதிலாக பிற ஆப்ஜெக்ட்களுக்கான குறிப்புகளைச் சேமிப்பதைக் கருத்தில் கொள்ளுங்கள்.
• பிழைகளை கவனமாகக் கையாளவும்: உங்கள் பிழை கையாளும் தர்க்கம் அசிங்க் கான்டெக்ஸை சரியாக சுத்தம் செய்வதை உறுதி செய்யவும். பிடிக்கப்படாத விதிவிலக்குகள் சூழலை ஒரு சீரற்ற நிலையில் விட்டுவிடக்கூடும்.
• செயல்திறன் தாக்கங்களைக் கருத்தில் கொள்ளுங்கள்: AsyncLocalStorage பொதுவாக செயல்திறன் மிக்கதாக இருந்தாலும், அதிகப்படியான பயன்பாடு அல்லது பெரிய சூழல் ஆப்ஜெக்ட்கள் செயல்திறனை பாதிக்கலாம். AsyncLocalStorage-ஐ செயல்படுத்திய பிறகு உங்கள் பயன்பாட்டின் செயல்திறனை அளவிடவும்.
• நூலகங்களில் எச்சரிக்கையுடன் பயன்படுத்தவும்: மற்றவர்களால் பயன்படுத்தப்பட வேண்டிய நூலகங்களுக்குள் AsyncLocalStorage-ஐப் பயன்படுத்துவதைத் தவிர்க்கவும், ஏனெனில் இது நுகர்வோர் பயன்பாட்டின் சொந்த AsyncLocalStorage பயன்பாட்டுடன் எதிர்பாராத நடத்தை மற்றும் முரண்பாடுகளுக்கு வழிவகுக்கும்.

அசிங்க் கான்டெக்ஸ்ட் வேரியபிள்களுக்கு மாற்றுகள்

அசிங்க் கான்டெக்ஸ்ட் வேரியபிள்கள் கோரிக்கை கண்காணிப்புக்கு ஒரு சக்திவாய்ந்த தீர்வை வழங்கினாலும், மாற்று அணுகுமுறைகளும் உள்ளன:

• கைமுறை சூழல் பரப்புதல்: சூழல் தரவை செயல்பாட்டு வாதங்களாக அனுப்புதல். இந்த அணுகுமுறை சிறிய பயன்பாடுகளுக்கு எளிமையானது, ஆனால் சிக்கல் அதிகரிக்கும்போது சிரமமானதாகவும் பிழை ஏற்பட வாய்ப்புள்ளதாகவும் மாறும்.
• மிடில்வேர்: கோரிக்கை ஆப்ஜெக்ட்களில் சூழல் தரவைச் செலுத்த மிடில்வேரைப் பயன்படுத்துதல். இந்த அணுகுமுறை Express.js போன்ற வலை கட்டமைப்புகளில் பொதுவானது.
• சூழல் பரப்புதல் நூலகங்கள்: சூழல் பரப்புதலுக்காக உயர்-நிலை சுருக்கங்களை வழங்கும் நூலகங்கள். இந்த நூலகங்கள் சிக்கலான தடமறிதல் காட்சிகளின் செயலாக்கத்தை எளிதாக்கலாம்.

அணுகுமுறையின் தேர்வு உங்கள் பயன்பாட்டின் குறிப்பிட்ட தேவைகளைப் பொறுத்தது. கைமுறை சூழல் பரப்புதலை நிர்வகிப்பது கடினமாக இருக்கும் சிக்கலான ஒத்திசைவற்ற வேலைப்பாய்வுகளுக்கு அசிங்க் கான்டெக்ஸ்ட் வேரியபிள்கள் மிகவும் பொருத்தமானவை.

முடிவுரை

அசிங்க் கான்டெக்ஸ்ட் வேரியபிள்கள் ஒத்திசைவற்ற ஜாவாஸ்கிரிப்ட் பயன்பாடுகளில் நிலை மற்றும் சூழலை நிர்வகிப்பதற்கு ஒரு சக்திவாய்ந்த மற்றும் நேர்த்தியான தீர்வை வழங்குகின்றன. கோரிக்கை கண்காணிப்புக்காக அசிங்க் கான்டெக்ஸ்ட் வேரியபிள்களைப் பயன்படுத்துவதன் மூலம், உங்கள் பயன்பாடுகளின் பிழைத்திருத்தம், பராமரிப்பு மற்றும் செயல்திறனை கணிசமாக மேம்படுத்தலாம். அடிப்படை கோரிக்கை ஐடி கண்காணிப்பு முதல் மேம்பட்ட பகிரப்பட்ட தடமறிதல் மற்றும் பதிவுசெய்தல் தொடர்புபடுத்துதல் வரை, AsyncLocalStorage மேலும் வலுவான மற்றும் கவனிக்கக்கூடிய அமைப்புகளை உருவாக்க உங்களுக்கு அதிகாரம் அளிக்கிறது. இந்த நுட்பங்களைப் புரிந்துகொண்டு செயல்படுத்துவது, குறிப்பாக சிக்கலான சர்வர்-சைட் சூழல்களில், ஒத்திசைவற்ற ஜாவாஸ்கிரிப்ட்டுடன் பணிபுரியும் எந்தவொரு டெவலப்பருக்கும் அவசியமானது.