ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅಸಿಂಕ್ ಕಾಂಟೆಕ್ಸ್ಟ್ ವೇರಿಯೇಬಲ್ಸ್: ರಿಕ್ವೆಸ್ಟ್ ಟ್ರ್ಯಾಕಿಂಗ್‌ ಕುರಿತು ಒಂದು ಆಳವಾದ ನೋಟ

ಅಸಿಂಕ್ರೋನಸ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಆಧುನಿಕ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅಭಿವೃದ್ಧಿಗೆ ಮೂಲಭೂತವಾಗಿದೆ, ವಿಶೇಷವಾಗಿ Node.js ನಂತಹ ಪರಿಸರದಲ್ಲಿ. ಆದರೆ, ಅಸಿಂಕ್ರೋನಸ್ ಕಾರ್ಯಾಚರಣೆಗಳಾದ್ಯಂತ ಸ್ಥಿತಿ (state) ಮತ್ತು ಸಂದರ್ಭವನ್ನು (context) ನಿರ್ವಹಿಸುವುದು ಸವಾಲಿನದ್ದಾಗಿರಬಹುದು. ಇಲ್ಲಿಯೇ ಅಸಿಂಕ್ ಕಾಂಟೆಕ್ಸ್ಟ್ ವೇರಿಯೇಬಲ್ಸ್ (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: ಡಿಸ್ಟ್ರಿಬ್ಯೂಟೆಡ್ ಟ್ರೇಸಿಂಗ್

ಬಹು ಮೈಕ್ರೋಸರ್ವಿಸ್‌ಗಳಿರುವ ಸಂಕೀರ್ಣ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗಾಗಿ, ಸೇವಾ ಗಡಿಗಳಾದ್ಯಂತ ಟ್ರೇಸಿಂಗ್ ಮಾಹಿತಿಯನ್ನು ಪ್ರಸಾರ ಮಾಡಲು ನೀವು ಅಸಿಂಕ್ ಕಾಂಟೆಕ್ಸ್ಟ್ ವೇರಿಯೇಬಲ್ಸ್‌ಗಳನ್ನು ಬಳಸಬಹುದು. ಇದು ಎಂಡ್-ಟು-ಎಂಡ್ ರಿಕ್ವೆಸ್ಟ್ ಟ್ರೇಸಿಂಗ್ ಅನ್ನು ಸಕ್ರಿಯಗೊಳಿಸುತ್ತದೆ, ಇದು ಕಾರ್ಯಕ್ಷಮತೆಯ ಅಡಚಣೆಗಳನ್ನು ಗುರುತಿಸಲು ಮತ್ತು ಡಿಸ್ಟ್ರಿಬ್ಯೂಟೆಡ್ ಸಿಸ್ಟಮ್‌ಗಳನ್ನು ಡೀಬಗ್ ಮಾಡಲು ಅವಶ್ಯಕವಾಗಿದೆ.

ಇದು ಸಾಮಾನ್ಯವಾಗಿ ರಿಕ್ವೆಸ್ಟ್‌ನ ಆರಂಭದಲ್ಲಿ ಒಂದು ಅನನ್ಯ ಟ್ರೇಸ್ ಐಡಿಯನ್ನು ರಚಿಸುವುದು ಮತ್ತು ಅದನ್ನು ಎಲ್ಲಾ ಡೌನ್‌ಸ್ಟ್ರೀಮ್ ಸೇವೆಗಳಿಗೆ ಪ್ರಸಾರ ಮಾಡುವುದನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ. 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
              
            
          

AsyncLocalStorage ನಿಂದ ರಿಕ್ವೆಸ್ಟ್ ಐಡಿಯನ್ನು ಸೇರಿಸಲು Winston ಲಾಗರ್ ಅನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡುವ ಮೂಲಕ, ರಿಕ್ವೆಸ್ಟ್ ಕಾಂಟೆಕ್ಸ್ಟ್‌ನಲ್ಲಿನ ಎಲ್ಲಾ ಲಾಗ್ ಸಂದೇಶಗಳು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ರಿಕ್ವೆಸ್ಟ್ ಐಡಿಯೊಂದಿಗೆ ಟ್ಯಾಗ್ ಆಗುತ್ತವೆ.

ಅಸಿಂಕ್ ಕಾಂಟೆಕ್ಸ್ಟ್ ವೇರಿಯೇಬಲ್ಸ್‌ಗಳನ್ನು ಬಳಸಲು ಉತ್ತಮ ಅಭ್ಯಾಸಗಳು

• AsyncLocalStorage ಅನ್ನು ಮೊದಲೇ ಇನಿಶಿಯಲೈಸ್ ಮಾಡಿ: ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ನ ಜೀವನಚಕ್ರದಲ್ಲಿ ಸಾಧ್ಯವಾದಷ್ಟು ಬೇಗ ನಿಮ್ಮ AsyncLocalStorage ಇನ್‌ಸ್ಟನ್ಸ್ ಅನ್ನು ರಚಿಸಿ ಮತ್ತು ಇನಿಶಿಯಲೈಸ್ ಮಾಡಿ. ಇದು ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ನಾದ್ಯಂತ ಲಭ್ಯವಿರುವುದನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ.
• ಸ್ಥಿರವಾದ ಹೆಸರಿಸುವ ಸಂಪ್ರದಾಯವನ್ನು ಬಳಸಿ: ನಿಮ್ಮ ಕಾಂಟೆಕ್ಸ್ಟ್ ವೇರಿಯೇಬಲ್‌ಗಳಿಗಾಗಿ ಸ್ಥಿರವಾದ ಹೆಸರಿಸುವ ಸಂಪ್ರದಾಯವನ್ನು ಸ್ಥಾಪಿಸಿ. ಇದು ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಮತ್ತು ನಿರ್ವಹಿಸಲು ಸುಲಭಗೊಳಿಸುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ನೀವು ಎಲ್ಲಾ ಕಾಂಟೆಕ್ಸ್ಟ್ ವೇರಿಯೇಬಲ್ ಹೆಸರುಗಳಿಗೆ acv_ ಪೂರ್ವಪ್ರತ್ಯಯವನ್ನು ನೀಡಬಹುದು.
• ಕಾಂಟೆಕ್ಸ್ಟ್ ಡೇಟಾವನ್ನು ಕಡಿಮೆ ಮಾಡಿ: ಅಸಿಂಕ್ ಕಾಂಟೆಕ್ಸ್ಟ್‌ನಲ್ಲಿ ಅಗತ್ಯ ಡೇಟಾವನ್ನು ಮಾತ್ರ ಸಂಗ್ರಹಿಸಿ. ದೊಡ್ಡ ಕಾಂಟೆಕ್ಸ್ಟ್ ಆಬ್ಜೆಕ್ಟ್‌ಗಳು ಕಾರ್ಯಕ್ಷಮತೆಯ ಮೇಲೆ ಪರಿಣಾಮ ಬೀರಬಹುದು. ಆಬ್ಜೆಕ್ಟ್‌ಗಳ ಬದಲಿಗೆ ಇತರ ಆಬ್ಜೆಕ್ಟ್‌ಗಳಿಗೆ ರೆಫರೆನ್ಸ್‌ಗಳನ್ನು ಸಂಗ್ರಹಿಸುವುದನ್ನು ಪರಿಗಣಿಸಿ.
• ದೋಷಗಳನ್ನು ಎಚ್ಚರಿಕೆಯಿಂದ ನಿರ್ವಹಿಸಿ: ನಿಮ್ಮ ದೋಷ ನಿರ್ವಹಣಾ ತರ್ಕವು ಅಸಿಂಕ್ ಕಾಂಟೆಕ್ಸ್ಟ್ ಅನ್ನು ಸರಿಯಾಗಿ ಸ್ವಚ್ಛಗೊಳಿಸುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ. ಹಿಡಿಯದ ಎಕ್ಸೆಪ್ಶನ್‌ಗಳು ಕಾಂಟೆಕ್ಸ್ಟ್ ಅನ್ನು ಅಸಂಗತ ಸ್ಥಿತಿಯಲ್ಲಿ ಬಿಡಬಹುದು.
• ಕಾರ್ಯಕ್ಷಮತೆಯ ಪರಿಣಾಮಗಳನ್ನು ಪರಿಗಣಿಸಿ: AsyncLocalStorage ಸಾಮಾನ್ಯವಾಗಿ ಕಾರ್ಯಕ್ಷಮತೆಯುಳ್ಳದ್ದಾಗಿದ್ದರೂ, ಅತಿಯಾದ ಬಳಕೆ ಅಥವಾ ದೊಡ್ಡ ಕಾಂಟೆಕ್ಸ್ಟ್ ಆಬ್ಜೆಕ್ಟ್‌ಗಳು ಕಾರ್ಯಕ್ಷಮತೆಯ ಮೇಲೆ ಪರಿಣಾಮ ಬೀರಬಹುದು. AsyncLocalStorage ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಿದ ನಂತರ ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ನ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಅಳೆಯಿರಿ.
• ಲೈಬ್ರರಿಗಳಲ್ಲಿ ಎಚ್ಚರಿಕೆಯಿಂದ ಬಳಸಿ: ಇತರರು ಬಳಸಲೆಂದು ಇರುವ ಲೈಬ್ರರಿಗಳಲ್ಲಿ AsyncLocalStorage ಬಳಸುವುದನ್ನು ತಪ್ಪಿಸಿ, ಏಕೆಂದರೆ ಇದು ಗ್ರಾಹಕ ಅಪ್ಲಿಕೇಶನ್‌ನ ಸ್ವಂತ AsyncLocalStorage ಬಳಕೆಯೊಂದಿಗೆ ಅನಿರೀಕ್ಷಿತ ನಡವಳಿಕೆ ಮತ್ತು ಸಂಘರ್ಷಗಳಿಗೆ ಕಾರಣವಾಗಬಹುದು.

ಅಸಿಂಕ್ ಕಾಂಟೆಕ್ಸ್ಟ್ ವೇರಿಯೇಬಲ್ಸ್‌ಗಳಿಗೆ ಪರ್ಯಾಯಗಳು

ಅಸಿಂಕ್ ಕಾಂಟೆಕ್ಸ್ಟ್ ವೇರಿಯೇಬಲ್ಸ್ ರಿಕ್ವೆಸ್ಟ್ ಟ್ರ್ಯಾಕಿಂಗ್‌ಗೆ ಶಕ್ತಿಯುತ ಪರಿಹಾರವನ್ನು ನೀಡುತ್ತವೆಯಾದರೂ, ಪರ್ಯಾಯ ವಿಧಾನಗಳು ಅಸ್ತಿತ್ವದಲ್ಲಿವೆ:

• ಹಸ್ತಚಾಲಿತ ಕಾಂಟೆಕ್ಸ್ಟ್ ಪ್ರಸರಣ: ಕಾಂಟೆಕ್ಸ್ಟ್ ಡೇಟಾವನ್ನು ಫಂಕ್ಷನ್ ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳಾಗಿ ರವಾನಿಸುವುದು. ಈ ವಿಧಾನವು ಸಣ್ಣ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗೆ ಸರಳವಾಗಿದೆ, ಆದರೆ ಸಂಕೀರ್ಣತೆ ಬೆಳೆದಂತೆ ತೊಡಕಿನ ಮತ್ತು ದೋಷ-ಪೀಡಿತವಾಗುತ್ತದೆ.
• ಮಿಡಲ್‌ವೇರ್: ರಿಕ್ವೆಸ್ಟ್ ಆಬ್ಜೆಕ್ಟ್‌ಗಳಿಗೆ ಕಾಂಟೆಕ್ಸ್ಟ್ ಡೇಟಾವನ್ನು ಸೇರಿಸಲು ಮಿಡಲ್‌ವೇರ್ ಅನ್ನು ಬಳಸುವುದು. ಈ ವಿಧಾನವು Express.js ನಂತಹ ವೆಬ್ ಫ್ರೇಮ್‌ವರ್ಕ್‌ಗಳಲ್ಲಿ ಸಾಮಾನ್ಯವಾಗಿದೆ.
• ಕಾಂಟೆಕ್ಸ್ಟ್ ಪ್ರಸರಣ ಲೈಬ್ರರಿಗಳು: ಕಾಂಟೆಕ್ಸ್ಟ್ ಪ್ರಸರಣಕ್ಕಾಗಿ ಉನ್ನತ-ಮಟ್ಟದ ಅಬ್ಸ್ಟ್ರಾಕ್ಷನ್‌ಗಳನ್ನು ಒದಗಿಸುವ ಲೈಬ್ರರಿಗಳು. ಈ ಲೈಬ್ರರಿಗಳು ಸಂಕೀರ್ಣ ಟ್ರೇಸಿಂಗ್ ಸನ್ನಿವೇಶಗಳ ಅನುಷ್ಠಾನವನ್ನು ಸರಳಗೊಳಿಸಬಹುದು.

ವಿಧಾನದ ಆಯ್ಕೆಯು ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ನ ನಿರ್ದಿಷ್ಟ ಅವಶ್ಯಕತೆಗಳನ್ನು ಅವಲಂಬಿಸಿರುತ್ತದೆ. ಅಸಿಂಕ್ ಕಾಂಟೆಕ್ಸ್ಟ್ ವೇರಿಯೇಬಲ್ಸ್ ವಿಶೇಷವಾಗಿ ಸಂಕೀರ್ಣ ಅಸಿಂಕ್ರೋನಸ್ ವರ್ಕ್‌ಫ್ಲೋಗಳಿಗೆ ಸೂಕ್ತವಾಗಿವೆ, ಅಲ್ಲಿ ಹಸ್ತಚಾಲಿತ ಕಾಂಟೆಕ್ಸ್ಟ್ ಪ್ರಸರಣವನ್ನು ನಿರ್ವಹಿಸುವುದು ಕಷ್ಟಕರವಾಗುತ್ತದೆ.

ತೀರ್ಮಾನ

ಅಸಿಂಕ್ ಕಾಂಟೆಕ್ಸ್ಟ್ ವೇರಿಯೇಬಲ್ಸ್ ಅಸಿಂಕ್ರೋನಸ್ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಲ್ಲಿ ಸ್ಥಿತಿ ಮತ್ತು ಕಾಂಟೆಕ್ಸ್ಟ್ ಅನ್ನು ನಿರ್ವಹಿಸಲು ಶಕ್ತಿಯುತ ಮತ್ತು ಸೊಗಸಾದ ಪರಿಹಾರವನ್ನು ಒದಗಿಸುತ್ತವೆ. ರಿಕ್ವೆಸ್ಟ್ ಟ್ರ್ಯಾಕಿಂಗ್‌ಗಾಗಿ ಅಸಿಂಕ್ ಕಾಂಟೆಕ್ಸ್ಟ್ ವೇರಿಯೇಬಲ್ಸ್‌ಗಳನ್ನು ಬಳಸುವ ಮೂಲಕ, ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ಗಳ ಡೀಬಗ್ಗಿಂಗ್, ನಿರ್ವಹಣೆ ಮತ್ತು ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ನೀವು ಗಮನಾರ್ಹವಾಗಿ ಸುಧಾರಿಸಬಹುದು. ಮೂಲಭೂತ ರಿಕ್ವೆಸ್ಟ್ ಐಡಿ ಟ್ರ್ಯಾಕಿಂಗ್‌ನಿಂದ ಹಿಡಿದು ಸುಧಾರಿತ ಡಿಸ್ಟ್ರಿಬ್ಯೂಟೆಡ್ ಟ್ರೇಸಿಂಗ್ ಮತ್ತು ಲಾಗಿಂಗ್ ಪರಸ್ಪರ ಸಂಬಂಧದವರೆಗೆ, AsyncLocalStorage ನಿಮಗೆ ಹೆಚ್ಚು ದೃಢವಾದ ಮತ್ತು ಗಮನಿಸಬಹುದಾದ ಸಿಸ್ಟಮ್‌ಗಳನ್ನು ನಿರ್ಮಿಸಲು ಅಧಿಕಾರ ನೀಡುತ್ತದೆ. ಈ ತಂತ್ರಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಮತ್ತು ಕಾರ್ಯಗತಗೊಳಿಸುವುದು ಅಸಿಂಕ್ರೋನಸ್ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವ ಯಾವುದೇ ಡೆವಲಪರ್‌ಗೆ, ವಿಶೇಷವಾಗಿ ಸಂಕೀರ್ಣ ಸರ್ವರ್-ಸೈಡ್ ಪರಿಸರದಲ್ಲಿ ಅತ್ಯಗತ್ಯ.