ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅಸಿಂಕ್ ಕಾಂಟೆಕ್ಸ್ಟ್ ಪ್ರೊಪಗೇಷನ್: AsyncLocalStorage ಬಳಸಿ ವಿನಂತಿ ಟ್ರೇಸಿಂಗ್ ಮತ್ತು ಕಂಟಿನ್ಯುಯೇಷನ್

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

ಅಸಿಂಕ್ರೊನಸ್ ಕಾಂಟೆಕ್ಸ್ಟ್ ಪ್ರೊಪಗೇಷನ್ ಅನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು

ಅಸಿಂಕ್ರೊನಸ್ ಕಾಂಟೆಕ್ಸ್ಟ್ ಪ್ರೊಪಗೇಷನ್ ಎಂದರೆ ಅಸಿಂಕ್ರೊನಸ್ ಕಾರ್ಯಾಚರಣೆಗಳಾದ್ಯಂತ ಕಾಂಟೆಕ್ಸ್ಟ್ ಮಾಹಿತಿಯನ್ನು (ಉದಾಹರಣೆಗೆ, ವಿನಂತಿ IDಗಳು, ಬಳಕೆದಾರರ ದೃಢೀಕರಣ ವಿವರಗಳು, ಕೋರಿಲೇಷನ್ IDಗಳು) ನಿರ್ವಹಿಸುವ ಮತ್ತು ಪ್ರಸಾರ ಮಾಡುವ ಸಾಮರ್ಥ್ಯ. ಸರಿಯಾದ ಕಾಂಟೆಕ್ಸ್ಟ್ ಪ್ರೊಪಗೇಷನ್ ಇಲ್ಲದೆ, ವಿನಂತಿಗಳನ್ನು ಟ್ರೇಸ್ ಮಾಡುವುದು, ಲಾಗ್‌ಗಳನ್ನು ಪರಸ್ಪರ ಸಂಬಂಧಿಸುವುದು ಮತ್ತು ವಿತರಿಸಿದ ವ್ಯವಸ್ಥೆಗಳಲ್ಲಿ ಕಾರ್ಯಕ್ಷಮತೆಯ ಸಮಸ್ಯೆಗಳನ್ನು ಪತ್ತೆಹಚ್ಚುವುದು ಕಷ್ಟಕರವಾಗುತ್ತದೆ.

ಕಾಂಟೆಕ್ಸ್ಟ್ ನಿರ್ವಹಣೆಯ ಸಾಂಪ್ರದಾಯಿಕ ವಿಧಾನಗಳು ಸಾಮಾನ್ಯವಾಗಿ ಫಂಕ್ಷನ್ ಕಾಲ್‌ಗಳ ಮೂಲಕ ಕಾಂಟೆಕ್ಸ್ಟ್ ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ರವಾನಿಸುವುದನ್ನು ಅವಲಂಬಿಸಿವೆ, ಇದು ದೀರ್ಘವಾದ ಮತ್ತು ದೋಷ-ಪೀಡಿತ ಕೋಡ್‌ಗೆ ಕಾರಣವಾಗಬಹುದು. AsyncLocalStorage ಏಕ ಎಕ್ಸಿಕ್ಯೂಷನ್ ಕಾಂಟೆಕ್ಸ್ಟ್ ಒಳಗೆ, ಅಸಿಂಕ್ರೊನಸ್ ಕಾರ್ಯಾಚರಣೆಗಳಾದ್ಯಂತವೂ ಸಹ, ಕಾಂಟೆಕ್ಸ್ಟ್ ಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸಲು ಮತ್ತು ಹಿಂಪಡೆಯಲು ಒಂದು ಮಾರ್ಗವನ್ನು ಒದಗಿಸುವ ಮೂಲಕ ಹೆಚ್ಚು ಸೊಗಸಾದ ಪರಿಹಾರವನ್ನು ನೀಡುತ್ತದೆ.

AsyncLocalStorage ಪರಿಚಯ

AsyncLocalStorage ಎಂಬುದು ಅಂತರ್ನಿರ್ಮಿತ Node.js ಮಾಡ್ಯೂಲ್ ಆಗಿದೆ (Node.js v14.5.0 ರಿಂದ ಲಭ್ಯವಿದೆ) ಇದು ಅಸಿಂಕ್ರೊನಸ್ ಕಾರ್ಯಾಚರಣೆಯ ಜೀವಿತಾವಧಿಯಲ್ಲಿ ಸ್ಥಳೀಯವಾಗಿರುವ ಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸಲು ಒಂದು ಮಾರ್ಗವನ್ನು ಒದಗಿಸುತ್ತದೆ. ಇದು ಮೂಲಭೂತವಾಗಿ await ಕಾಲ್‌ಗಳು, ಪ್ರಾಮಿಸ್‌ಗಳು ಮತ್ತು ಇತರ ಅಸಿಂಕ್ರೊನಸ್ ಗಡಿಗಳಾದ್ಯಂತ ಸಂರಕ್ಷಿಸಲ್ಪಟ್ಟ ಸಂಗ್ರಹಣಾ ಸ್ಥಳವನ್ನು ಸೃಷ್ಟಿಸುತ್ತದೆ. ಇದು ಡೆವಲಪರ್‌ಗಳಿಗೆ ಕಾಂಟೆಕ್ಸ್ಟ್ ಡೇಟಾವನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ರವಾನಿಸದೆ ಪ್ರವೇಶಿಸಲು ಮತ್ತು ಮಾರ್ಪಡಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ.

AsyncLocalStorage ನ ಪ್ರಮುಖ ವೈಶಿಷ್ಟ್ಯಗಳು:

• ಸ್ವಯಂಚಾಲಿತ ಕಾಂಟೆಕ್ಸ್ಟ್ ಪ್ರೊಪಗೇಷನ್: AsyncLocalStorage ನಲ್ಲಿ ಸಂಗ್ರಹವಾಗಿರುವ ಮೌಲ್ಯಗಳು ಒಂದೇ ಎಕ್ಸಿಕ್ಯೂಷನ್ ಕಾಂಟೆಕ್ಸ್ಟ್ ಒಳಗೆ ಅಸಿಂಕ್ರೊನಸ್ ಕಾರ್ಯಾಚರಣೆಗಳಾದ್ಯಂತ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಪ್ರಸಾರವಾಗುತ್ತವೆ.
• ಸರಳೀಕೃತ ಕೋಡ್: ಫಂಕ್ಷನ್ ಕಾಲ್‌ಗಳ ಮೂಲಕ ಕಾಂಟೆಕ್ಸ್ಟ್ ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ರವಾನಿಸುವ ಅಗತ್ಯವನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ.
• ಸುಧಾರಿತ ವೀಕ್ಷಣೀಯತೆ: ವಿನಂತಿ ಟ್ರೇಸಿಂಗ್ ಮತ್ತು ಲಾಗ್‌ಗಳು ಮತ್ತು ಮೆಟ್ರಿಕ್‌ಗಳ ಪರಸ್ಪರ ಸಂಬಂಧವನ್ನು ಸುಗಮಗೊಳಿಸುತ್ತದೆ.
• ಥ್ರೆಡ್-ಸುರಕ್ಷತೆ: ಪ್ರಸ್ತುತ ಎಕ್ಸಿಕ್ಯೂಷನ್ ಕಾಂಟೆಕ್ಸ್ಟ್ ಒಳಗೆ ಕಾಂಟೆಕ್ಸ್ಟ್ ಡೇಟಾಗೆ ಥ್ರೆಡ್-ಸುರಕ್ಷಿತ ಪ್ರವೇಶವನ್ನು ಒದಗಿಸುತ್ತದೆ.

AsyncLocalStorage ಗಾಗಿ ಬಳಕೆಯ ಪ್ರಕರಣಗಳು

AsyncLocalStorage ವಿವಿಧ ಸನ್ನಿವೇಶಗಳಲ್ಲಿ ಮೌಲ್ಯಯುತವಾಗಿದೆ, ಅವುಗಳೆಂದರೆ:

• ವಿನಂತಿ ಟ್ರೇಸಿಂಗ್: ಪ್ರತಿ ಒಳಬರುವ ವಿನಂತಿಗೆ ಒಂದು ಅನನ್ಯ ID ಯನ್ನು ನಿಯೋಜಿಸುವುದು ಮತ್ತು ಟ್ರೇಸಿಂಗ್ ಉದ್ದೇಶಗಳಿಗಾಗಿ ವಿನಂತಿಯ ಜೀವನಚಕ್ರದ ಉದ್ದಕ್ಕೂ ಅದನ್ನು ಪ್ರಸಾರ ಮಾಡುವುದು.
• ದೃಢೀಕರಣ ಮತ್ತು ಅಧಿಕಾರ: ಸಂರಕ್ಷಿತ ಸಂಪನ್ಮೂಲಗಳನ್ನು ಪ್ರವೇಶಿಸಲು ಬಳಕೆದಾರರ ದೃಢೀಕರಣ ವಿವರಗಳನ್ನು (ಉದಾಹರಣೆಗೆ, ಬಳಕೆದಾರ ID, ಪಾತ್ರಗಳು, ಅನುಮತಿಗಳು) ಸಂಗ್ರಹಿಸುವುದು.
• ಲಾಗಿಂಗ್ ಮತ್ತು ಆಡಿಟಿಂಗ್: ಉತ್ತಮ ಡೀಬಗ್ಗಿಂಗ್ ಮತ್ತು ಆಡಿಟಿಂಗ್‌ಗಾಗಿ ಲಾಗ್ ಸಂದೇಶಗಳಿಗೆ ವಿನಂತಿ-ನಿರ್ದಿಷ್ಟ ಮೆಟಾಡೇಟಾವನ್ನು ಲಗತ್ತಿಸುವುದು.
• ಕಾರ್ಯಕ್ಷಮತೆ ಮಾನಿಟರಿಂಗ್: ಕಾರ್ಯಕ್ಷಮತೆ ವಿಶ್ಲೇಷಣೆಗಾಗಿ ವಿನಂತಿಯೊಳಗೆ ವಿವಿಧ ಘಟಕಗಳ ಎಕ್ಸಿಕ್ಯೂಷನ್ ಸಮಯವನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡುವುದು.
• ವಹಿವಾಟು ನಿರ್ವಹಣೆ: ಬಹು ಅಸಿಂಕ್ರೊನಸ್ ಕಾರ್ಯಾಚರಣೆಗಳಾದ್ಯಂತ ವಹಿವಾಟು ಸ್ಥಿತಿಯನ್ನು ನಿರ್ವಹಿಸುವುದು (ಉದಾಹರಣೆಗೆ, ಡೇಟಾಬೇಸ್ ವಹಿವಾಟುಗಳು).

ಪ್ರಾಯೋಗಿಕ ಉದಾಹರಣೆ: AsyncLocalStorage ನೊಂದಿಗೆ ವಿನಂತಿ ಟ್ರೇಸಿಂಗ್

ಸರಳವಾದ Node.js ಅಪ್ಲಿಕೇಶನ್‌ನಲ್ಲಿ ವಿನಂತಿ ಟ್ರೇಸಿಂಗ್‌ಗಾಗಿ AsyncLocalStorage ಅನ್ನು ಹೇಗೆ ಬಳಸುವುದು ಎಂಬುದನ್ನು ವಿವರಿಸೋಣ. ನಾವು ಪ್ರತಿ ಒಳಬರುವ ವಿನಂತಿಗೆ ಒಂದು ಅನನ್ಯ ID ಯನ್ನು ನಿಯೋಜಿಸುವ ಮತ್ತು ವಿನಂತಿಯ ಜೀವನಚಕ್ರದ ಉದ್ದಕ್ಕೂ ಅದನ್ನು ಲಭ್ಯವಾಗುವಂತೆ ಮಾಡುವ ಮಿಡಲ್‌ವೇರ್ ಅನ್ನು ರಚಿಸುತ್ತೇವೆ.

ಕೋಡ್ ಉದಾಹರಣೆ

ಮೊದಲು, ಅಗತ್ಯವಿರುವ ಪ್ಯಾಕೇಜ್‌ಗಳನ್ನು ಸ್ಥಾಪಿಸಿ (ಅಗತ್ಯವಿದ್ದರೆ):

            npm install uuid express
            

              
                Copy
              
            
          

ಕೋಡ್ ಇಲ್ಲಿದೆ:

            // 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;

// Middleware to assign a request ID and store it in AsyncLocalStorage
app.use((req, res, next) => {
  const requestId = uuidv4();
  asyncLocalStorage.run(new Map(), () => {
    asyncLocalStorage.getStore().set('requestId', requestId);
    next();
  });
});

// Simulate an asynchronous operation
async function doSomethingAsync() {
  return new Promise(resolve => {
    setTimeout(() => {
      const requestId = asyncLocalStorage.getStore().get('requestId');
      console.log(`[Async] Request ID: ${requestId}`);
      resolve();
    }, 50);
  });
}

// 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
              
            
          

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ:

1. ನಾವು AsyncLocalStorage ಇನ್‌ಸ್ಟಾನ್ಸ್ ಅನ್ನು ರಚಿಸುತ್ತೇವೆ.
2. ನಾವು uuid ಲೈಬ್ರರಿಯನ್ನು ಬಳಸಿಕೊಂಡು ಪ್ರತಿ ಒಳಬರುವ ವಿನಂತಿಗೆ ಒಂದು ಅನನ್ಯ ID ಯನ್ನು ನಿಯೋಜಿಸುವ ಮಿಡಲ್‌ವೇರ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತೇವೆ.
3. ನಾವು AsyncLocalStorage ನ ಕಾಂಟೆಕ್ಸ್ಟ್ ಒಳಗೆ ವಿನಂತಿ ಹ್ಯಾಂಡ್ಲರ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು asyncLocalStorage.run() ಅನ್ನು ಬಳಸುತ್ತೇವೆ. ಇದು AsyncLocalStorage ನಲ್ಲಿ ಸಂಗ್ರಹವಾಗಿರುವ ಯಾವುದೇ ಮೌಲ್ಯಗಳು ವಿನಂತಿಯ ಜೀವನಚಕ್ರದ ಉದ್ದಕ್ಕೂ ಲಭ್ಯವಿರುವುದನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ.
4. ಮಿಡಲ್‌ವೇರ್ ಒಳಗೆ, ನಾವು asyncLocalStorage.getStore().set('requestId', requestId) ಬಳಸಿ AsyncLocalStorage ನಲ್ಲಿ ವಿನಂತಿ ID ಯನ್ನು ಸಂಗ್ರಹಿಸುತ್ತೇವೆ.
5. ನಾವು ಅಸಿಂಕ್ರೊನಸ್ ಕಾರ್ಯಾಚರಣೆಯನ್ನು ಅನುಕರಿಸುವ ಮತ್ತು AsyncLocalStorage ನಿಂದ ವಿನಂತಿ ID ಯನ್ನು ಹಿಂಪಡೆಯುವ doSomethingAsync() ಎಂಬ ಅಸಿಂಕ್ರೊನಸ್ ಫಂಕ್ಷನ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತೇವೆ.
6. ರೂಟ್ ಹ್ಯಾಂಡ್ಲರ್‌ನಲ್ಲಿ, ನಾವು AsyncLocalStorage ನಿಂದ ವಿನಂತಿ ID ಯನ್ನು ಹಿಂಪಡೆಯುತ್ತೇವೆ ಮತ್ತು ಅದನ್ನು ಪ್ರತಿಕ್ರಿಯೆಯಲ್ಲಿ ಸೇರಿಸುತ್ತೇವೆ.

ನೀವು ಈ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ರನ್ ಮಾಡಿದಾಗ ಮತ್ತು http://localhost:3000 ಗೆ ವಿನಂತಿಯನ್ನು ಕಳುಹಿಸಿದಾಗ, ರೂಟ್ ಹ್ಯಾಂಡ್ಲರ್ ಮತ್ತು ಅಸಿಂಕ್ರೊನಸ್ ಫಂಕ್ಷನ್ ಎರಡರಲ್ಲೂ ವಿನಂತಿ ID ಲಾಗ್ ಆಗಿರುವುದನ್ನು ನೀವು ನೋಡುತ್ತೀರಿ, ಇದು ಕಾಂಟೆಕ್ಸ್ಟ್ ಸರಿಯಾಗಿ ಪ್ರಸಾರವಾಗಿದೆ ಎಂಬುದನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತದೆ.

ವಿವರಣೆ

• AsyncLocalStorage ಇನ್‌ಸ್ಟಾನ್ಸ್: ನಾವು ನಮ್ಮ ಕಾಂಟೆಕ್ಸ್ಟ್ ಡೇಟಾವನ್ನು ಹಿಡಿದಿಟ್ಟುಕೊಳ್ಳುವ AsyncLocalStorage ನ ಇನ್‌ಸ್ಟಾನ್ಸ್ ಅನ್ನು ರಚಿಸುತ್ತೇವೆ.
• ಮಿಡಲ್‌ವೇರ್: ಮಿಡಲ್‌ವೇರ್ ಪ್ರತಿ ಒಳಬರುವ ವಿನಂತಿಯನ್ನು ತಡೆಯುತ್ತದೆ. ಇದು UUID ಅನ್ನು ರಚಿಸುತ್ತದೆ ಮತ್ತು ನಂತರ ಈ ಸ್ಟೋರೇಜ್‌ನ ಕಾಂಟೆಕ್ಸ್ಟ್ *ಒಳಗೆ* ಉಳಿದ ವಿನಂತಿ ಹ್ಯಾಂಡ್ಲಿಂಗ್ ಪೈಪ್‌ಲೈನ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು asyncLocalStorage.run ಅನ್ನು ಬಳಸುತ್ತದೆ. ಇದು ನಿರ್ಣಾಯಕವಾಗಿದೆ; ಇದು ಡೌನ್‌ಸ್ಟ್ರೀಮ್‌ನಲ್ಲಿರುವ ಎಲ್ಲವೂ ಸಂಗ್ರಹಿಸಿದ ಡೇಟಾಗೆ ಪ್ರವೇಶವನ್ನು ಹೊಂದಿದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ.
• asyncLocalStorage.run(new Map(), ...): ಈ ವಿಧಾನವು ಎರಡು ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ: ಹೊಸ, ಖಾಲಿ Map (ನಿಮ್ಮ ಕಾಂಟೆಕ್ಸ್ಟ್‌ಗೆ ಸೂಕ್ತವಾದರೆ ನೀವು ಇತರ ಡೇಟಾ ರಚನೆಗಳನ್ನು ಬಳಸಬಹುದು) ಮತ್ತು ಕಾಲ್‌ಬ್ಯಾಕ್ ಫಂಕ್ಷನ್. ಕಾಲ್‌ಬ್ಯಾಕ್ ಫಂಕ್ಷನ್ ಅಸಿಂಕ್ರೊನಸ್ ಕಾಂಟೆಕ್ಸ್ಟ್ ಒಳಗೆ ಕಾರ್ಯಗತಗೊಳ್ಳಬೇಕಾದ ಕೋಡ್ ಅನ್ನು ಹೊಂದಿರುತ್ತದೆ. ಈ ಕಾಲ್‌ಬ್ಯಾಕ್ ಒಳಗೆ ಪ್ರಾರಂಭಿಸಲಾದ ಯಾವುದೇ ಅಸಿಂಕ್ರೊನಸ್ ಕಾರ್ಯಾಚರಣೆಗಳು Map ನಲ್ಲಿ ಸಂಗ್ರಹವಾಗಿರುವ ಡೇಟಾವನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಆನುವಂಶಿಕವಾಗಿ ಪಡೆಯುತ್ತವೆ.
• asyncLocalStorage.getStore(): ಇದು asyncLocalStorage.run ಗೆ ರವಾನಿಸಲಾದ Map ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ವಿನಂತಿ ID ಯನ್ನು ಸಂಗ್ರಹಿಸಲು ಮತ್ತು ಹಿಂಪಡೆಯಲು ನಾವು ಇದನ್ನು ಬಳಸುತ್ತೇವೆ. run ಅನ್ನು ಕಾಲ್ ಮಾಡದಿದ್ದರೆ, ಇದು undefined ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ, ಅದಕ್ಕಾಗಿಯೇ ಮಿಡಲ್‌ವೇರ್ ಒಳಗೆ run ಅನ್ನು ಕಾಲ್ ಮಾಡುವುದು ಮುಖ್ಯವಾಗಿದೆ.
• ಅಸಿಂಕ್ರೊನಸ್ ಫಂಕ್ಷನ್: doSomethingAsync ಫಂಕ್ಷನ್ ಒಂದು ಅಸಿಂಕ್ರೊನಸ್ ಕಾರ್ಯಾಚರಣೆಯನ್ನು ಅನುಕರಿಸುತ್ತದೆ. ಮುಖ್ಯವಾಗಿ, ಇದು ಅಸಿಂಕ್ರೊನಸ್ ಆಗಿದ್ದರೂ (setTimeout ಬಳಸಿ), ಇದು asyncLocalStorage.run ನಿಂದ ಸ್ಥಾಪಿಸಲಾದ ಕಾಂಟೆಕ್ಸ್ಟ್ ಒಳಗೆ ರನ್ ಆಗುತ್ತಿರುವುದರಿಂದ ವಿನಂತಿ ID ಗೆ ಪ್ರವೇಶವನ್ನು ಹೊಂದಿದೆ.

ಸುಧಾರಿತ ಬಳಕೆ: ಲಾಗಿಂಗ್ ಲೈಬ್ರರಿಗಳೊಂದಿಗೆ ಸಂಯೋಜಿಸುವುದು

AsyncLocalStorage ಅನ್ನು ಲಾಗಿಂಗ್ ಲೈಬ್ರರಿಗಳೊಂದಿಗೆ (ವಿನ್ಸ್ಟನ್ ಅಥವಾ ಪಿನೊ ನಂತಹ) ಸಂಯೋಜಿಸುವುದು ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ಗಳ ವೀಕ್ಷಣೀಯತೆಯನ್ನು ಗಮನಾರ್ಹವಾಗಿ ಹೆಚ್ಚಿಸುತ್ತದೆ. ಲಾಗ್ ಸಂದೇಶಗಳಲ್ಲಿ ಕಾಂಟೆಕ್ಸ್ಟ್ ಡೇಟಾವನ್ನು (ಉದಾಹರಣೆಗೆ, ವಿನಂತಿ ID, ಬಳಕೆದಾರ ID) ಸೇರಿಸುವ ಮೂಲಕ, ನೀವು ಲಾಗ್‌ಗಳನ್ನು ಸುಲಭವಾಗಿ ಪರಸ್ಪರ ಸಂಬಂಧಿಸಬಹುದು ಮತ್ತು ವಿವಿಧ ಘಟಕಗಳಾದ್ಯಂತ ವಿನಂತಿಗಳನ್ನು ಟ್ರೇಸ್ ಮಾಡಬಹುದು.

ವಿನ್ಸ್ಟನ್ ಜೊತೆ ಉದಾಹರಣೆ

            // 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 (modified)
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}`); // Log the incoming request
    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
              
            
          

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ:

• ನಾವು ವಿನ್ಸ್ಟನ್ ಲಾಗರ್ ಇನ್‌ಸ್ಟಾನ್ಸ್ ಅನ್ನು ರಚಿಸುತ್ತೇವೆ ಮತ್ತು ಪ್ರತಿ ಲಾಗ್ ಸಂದೇಶದಲ್ಲಿ AsyncLocalStorage ನಿಂದ ವಿನಂತಿ ID ಯನ್ನು ಸೇರಿಸಲು ಅದನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡುತ್ತೇವೆ. ಇಲ್ಲಿ ಪ್ರಮುಖ ಭಾಗವೆಂದರೆ winston.format.printf, ಇದು AsyncLocalStorage ನಿಂದ ವಿನಂತಿ ID ಯನ್ನು (ಲಭ್ಯವಿದ್ದರೆ) ಹಿಂಪಡೆಯುತ್ತದೆ. ವಿನಂತಿಯ ಕಾಂಟೆಕ್ಸ್ಟ್‌ನ ಹೊರಗೆ ಲಾಗಿಂಗ್ ಮಾಡುವಾಗ ದೋಷಗಳನ್ನು ತಪ್ಪಿಸಲು asyncLocalStorage.getStore() ಅಸ್ತಿತ್ವದಲ್ಲಿದೆಯೇ ಎಂದು ನಾವು ಪರಿಶೀಲಿಸುತ್ತೇವೆ.
• ಒಳಬರುವ ವಿನಂತಿಯ URL ಅನ್ನು ಲಾಗ್ ಮಾಡಲು ನಾವು ಮಿಡಲ್‌ವೇರ್ ಅನ್ನು ನವೀಕರಿಸುತ್ತೇವೆ.
• ಕಾನ್ಫಿಗರ್ ಮಾಡಿದ ಲಾಗರ್ ಬಳಸಿ ಸಂದೇಶಗಳನ್ನು ಲಾಗ್ ಮಾಡಲು ನಾವು ರೂಟ್ ಹ್ಯಾಂಡ್ಲರ್ ಮತ್ತು ಅಸಿಂಕ್ರೊನಸ್ ಫಂಕ್ಷನ್ ಅನ್ನು ನವೀಕರಿಸುತ್ತೇವೆ.

ಈಗ, ಎಲ್ಲಾ ಲಾಗ್ ಸಂದೇಶಗಳು ವಿನಂತಿ ID ಯನ್ನು ಒಳಗೊಂಡಿರುತ್ತವೆ, ಇದು ವಿನಂತಿಗಳನ್ನು ಟ್ರೇಸ್ ಮಾಡಲು ಮತ್ತು ಲಾಗ್‌ಗಳನ್ನು ಪರಸ್ಪರ ಸಂಬಂಧಿಸಲು ಸುಲಭವಾಗಿಸುತ್ತದೆ.

ಪರ್ಯಾಯ ವಿಧಾನಗಳು: cls-hooked ಮತ್ತು ಅಸಿಂಕ್ ಹುಕ್ಸ್

AsyncLocalStorage ಲಭ್ಯವಾಗುವ ಮೊದಲು, ಅಸಿಂಕ್ರೊನಸ್ ಕಾಂಟೆಕ್ಸ್ಟ್ ಪ್ರೊಪಗೇಷನ್‌ಗಾಗಿ cls-hooked ನಂತಹ ಲೈಬ್ರರಿಗಳನ್ನು ಸಾಮಾನ್ಯವಾಗಿ ಬಳಸಲಾಗುತ್ತಿತ್ತು. cls-hooked ಇದೇ ರೀತಿಯ ಕಾರ್ಯವನ್ನು ಸಾಧಿಸಲು ಅಸಿಂಕ್ ಹುಕ್ಸ್ (ಕಡಿಮೆ-ಮಟ್ಟದ Node.js API) ಅನ್ನು ಬಳಸುತ್ತದೆ. cls-hooked ಅನ್ನು ಇನ್ನೂ ವ್ಯಾಪಕವಾಗಿ ಬಳಸಲಾಗಿದ್ದರೂ, AsyncLocalStorage ಅದರ ಅಂತರ್ನಿರ್ಮಿತ ಸ್ವರೂಪ ಮತ್ತು ಸುಧಾರಿತ ಕಾರ್ಯಕ್ಷಮತೆಯಿಂದಾಗಿ ಸಾಮಾನ್ಯವಾಗಿ ಆದ್ಯತೆ ನೀಡಲಾಗುತ್ತದೆ.

ಅಸಿಂಕ್ ಹುಕ್ಸ್ (async_hooks)

ಅಸಿಂಕ್ ಹುಕ್ಸ್ ಅಸಿಂಕ್ರೊನಸ್ ಕಾರ್ಯಾಚರಣೆಗಳ ಜೀವನಚಕ್ರವನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡಲು ಕಡಿಮೆ-ಮಟ್ಟದ API ಅನ್ನು ಒದಗಿಸುತ್ತವೆ. AsyncLocalStorage ಅಸಿಂಕ್ ಹುಕ್ಸ್‌ಗಳ ಮೇಲೆ ನಿರ್ಮಿಸಲಾಗಿದ್ದರೂ, ನೇರವಾಗಿ ಅಸಿಂಕ್ ಹುಕ್ಸ್‌ಗಳನ್ನು ಬಳಸುವುದು ಸಾಮಾನ್ಯವಾಗಿ ಹೆಚ್ಚು ಸಂಕೀರ್ಣ ಮತ್ತು ಕಡಿಮೆ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಹೊಂದಿರುತ್ತದೆ. ಅಸಿಂಕ್ರೊನಸ್ ಜೀವನಚಕ್ರದ ಮೇಲೆ ಸೂಕ್ಷ್ಮ-ಧಾನ್ಯದ ನಿಯಂತ್ರಣದ ಅಗತ್ಯವಿರುವ ಬಹಳ ನಿರ್ದಿಷ್ಟ, ಸುಧಾರಿತ ಬಳಕೆಯ ಪ್ರಕರಣಗಳಿಗೆ ಅಸಿಂಕ್ ಹುಕ್ಸ್‌ಗಳು ಹೆಚ್ಚು ಸೂಕ್ತವಾಗಿವೆ. ಸಂಪೂರ್ಣವಾಗಿ ಅಗತ್ಯವಿಲ್ಲದಿದ್ದರೆ ನೇರವಾಗಿ ಅಸಿಂಕ್ ಹುಕ್ಸ್‌ಗಳನ್ನು ಬಳಸುವುದನ್ನು ತಪ್ಪಿಸಿ.

cls-hooked ಗಿಂತ AsyncLocalStorage ಗೆ ಏಕೆ ಆದ್ಯತೆ ನೀಡಬೇಕು?

• ಅಂತರ್ನಿರ್ಮಿತ: AsyncLocalStorage Node.js ಕೋರ್‌ನ ಭಾಗವಾಗಿದೆ, ಬಾಹ್ಯ ಅವಲಂಬನೆಗಳ ಅಗತ್ಯವನ್ನು ನಿವಾರಿಸುತ್ತದೆ.
• ಕಾರ್ಯಕ್ಷಮತೆ: AsyncLocalStorage ಅದರ ಆಪ್ಟಿಮೈಸ್ಡ್ ಅನುಷ್ಠಾನದಿಂದಾಗಿ ಸಾಮಾನ್ಯವಾಗಿ cls-hooked ಗಿಂತ ಹೆಚ್ಚು ಕಾರ್ಯಕ್ಷಮತೆ ಹೊಂದಿದೆ.
• ನಿರ್ವಹಣೆ: ಅಂತರ್ನಿರ್ಮಿತ ಮಾಡ್ಯೂಲ್ ಆಗಿ, AsyncLocalStorage ಅನ್ನು Node.js ಕೋರ್ ತಂಡವು ಸಕ್ರಿಯವಾಗಿ ನಿರ್ವಹಿಸುತ್ತದೆ.

ಪರಿಗಣನೆಗಳು ಮತ್ತು ಮಿತಿಗಳು

AsyncLocalStorage ಒಂದು ಶಕ್ತಿಯುತ ಸಾಧನವಾಗಿದ್ದರೂ, ಅದರ ಮಿತಿಗಳ ಬಗ್ಗೆ ತಿಳಿದಿರುವುದು ಮುಖ್ಯ:

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

AsyncLocalStorage ಬಳಸಲು ಉತ್ತಮ ಅಭ್ಯಾಸಗಳು

AsyncLocalStorage ಅನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಬಳಸಲು, ಈ ಕೆಳಗಿನ ಉತ್ತಮ ಅಭ್ಯಾಸಗಳನ್ನು ಪರಿಗಣಿಸಿ:

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

OpenTelemetry ಜೊತೆಗಿನ ಏಕೀಕರಣ

OpenTelemetry ಒಂದು ಓಪನ್-ಸೋರ್ಸ್ ವೀಕ್ಷಣೀಯತೆ ಫ್ರೇಮ್‌ವರ್ಕ್ ಆಗಿದ್ದು ಅದು ಟೆಲಿಮೆಟ್ರಿ ಡೇಟಾವನ್ನು (ಉದಾಹರಣೆಗೆ, ಟ್ರೇಸ್‌ಗಳು, ಮೆಟ್ರಿಕ್‌ಗಳು, ಲಾಗ್‌ಗಳು) ಸಂಗ್ರಹಿಸಲು ಮತ್ತು ರಫ್ತು ಮಾಡಲು APIಗಳು, SDKಗಳು ಮತ್ತು ಪರಿಕರಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ. ಅಸಿಂಕ್ರೊನಸ್ ಕಾರ್ಯಾಚರಣೆಗಳಾದ್ಯಂತ ಟ್ರೇಸ್ ಕಾಂಟೆಕ್ಸ್ಟ್ ಅನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಪ್ರಸಾರ ಮಾಡಲು AsyncLocalStorage ಅನ್ನು OpenTelemetry ಯೊಂದಿಗೆ ಮನಬಂದಂತೆ ಸಂಯೋಜಿಸಬಹುದು.

OpenTelemetry ವಿವಿಧ ಸೇವೆಗಳಾದ್ಯಂತ ಟ್ರೇಸ್‌ಗಳನ್ನು ಪರಸ್ಪರ ಸಂಬಂಧಿಸಲು ಕಾಂಟೆಕ್ಸ್ಟ್ ಪ್ರೊಪಗೇಷನ್ ಮೇಲೆ ಹೆಚ್ಚು ಅವಲಂಬಿತವಾಗಿದೆ. AsyncLocalStorage ಅನ್ನು ಬಳಸುವ ಮೂಲಕ, ನಿಮ್ಮ Node.js ಅಪ್ಲಿಕೇಶನ್‌ನಲ್ಲಿ ಟ್ರೇಸ್ ಕಾಂಟೆಕ್ಸ್ಟ್ ಸರಿಯಾಗಿ ಪ್ರಸಾರವಾಗಿದೆ ಎಂದು ನೀವು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಬಹುದು, ಇದು ನಿಮಗೆ ಸಮಗ್ರ ವಿತರಿಸಿದ ಟ್ರೇಸಿಂಗ್ ವ್ಯವಸ್ಥೆಯನ್ನು ನಿರ್ಮಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ.

ಅನೇಕ OpenTelemetry SDKಗಳು ಕಾಂಟೆಕ್ಸ್ಟ್ ಪ್ರೊಪಗೇಷನ್‌ಗಾಗಿ ಸ್ವಯಂಚಾಲಿತವಾಗಿ AsyncLocalStorage (ಅಥವಾ AsyncLocalStorage ಲಭ್ಯವಿಲ್ಲದಿದ್ದರೆ cls-hooked) ಅನ್ನು ಬಳಸಿಕೊಳ್ಳುತ್ತವೆ. ನಿರ್ದಿಷ್ಟ ವಿವರಗಳಿಗಾಗಿ ನೀವು ಆಯ್ಕೆಮಾಡಿದ OpenTelemetry SDK ಯ ದಸ್ತಾವೇಜನ್ನು ಪರಿಶೀಲಿಸಿ.

ತೀರ್ಮಾನ

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