Async Local Storage ב-JavaScript: שליטה בניהול הקשר בסביבות אסינכרוניות

תכנות אסינכרוני הוא יסוד ב-JavaScript מודרני, במיוחד ב-Node.js ליישומי צד-שרת ויותר ויותר גם בדפדפן. עם זאת, ניהול הקשר (context) – נתונים ספציפיים לבקשה, לסשן משתמש או לטרנזקציה – על פני פעולות אסינכרוניות יכול להיות מאתגר. טכניקות סטנדרטיות כמו העברת נתונים דרך קריאות לפונקציות עלולות להפוך למסורבלות ונוטות לשגיאות, במיוחד ביישומים מורכבים. כאן נכנס לתמונה Async Local Storage (ALS) כפתרון רב-עוצמה.

מהו Async Local Storage (ALS)?

Async Local Storage (ALS) מספק דרך לאחסן נתונים שהם מקומיים לפעולה אסינכרונית ספציפית. חשבו על זה כמו thread-local storage בשפות תכנות אחרות, אך מותאם למודל החד-הליכי (single-threaded) מבוסס-האירועים של JavaScript. ALS מאפשר לקשר נתונים להקשר הביצוע האסינכרוני הנוכחי, מה שהופך אותם לנגישים לאורך כל שרשרת הקריאות האסינכרונית, מבלי להעביר אותם במפורש כארגומנטים.

בעצם, ALS יוצר מרחב אחסון שמופץ אוטומטית דרך פעולות אסינכרוניות שנוצרו באותו הקשר. זה מפשט את ניהול ההקשר ומפחית משמעותית את קוד ה-boilerplate הנדרש לשמירת מצב (state) על פני גבולות אסינכרוניים.

למה להשתמש ב-Async Local Storage?

ALS מציע מספר יתרונות מרכזיים בפיתוח JavaScript אסינכרוני:

• ניהול הקשר פשוט: הימנעות מהעברת משתני הקשר דרך קריאות מרובות לפונקציות, מה שמפחית את עומס הקוד ומשפר את הקריאות.
• ניפוי באגים משופר: מעקב קל אחר נתונים ספציפיים לבקשה לאורך כל מחסנית הקריאות האסינכרונית, מה שמקל על ניפוי באגים ופתרון בעיות.
• הפחתת Boilerplate: ביטול הצורך להפיץ הקשר באופן ידני, מה שמוביל לקוד נקי וקל יותר לתחזוקה.
• ביצועים משופרים: הפצת ההקשר מטופלת באופן אוטומטי, מה שממזער את תוספת העלות לביצועים הקשורה להעברת הקשר ידנית.
• גישה מרכזית להקשר: מספק מיקום יחיד ומוגדר היטב לגישה לנתוני הקשר, מה שמפשט את הגישה והשינוי.

מקרי שימוש ל-Async Local Storage

ALS שימושי במיוחד בתרחישים שבהם צריך לעקוב אחר נתונים ספציפיים לבקשה על פני פעולות אסינכרוניות. הנה כמה מקרי שימוש נפוצים:

1. מעקב אחר בקשות בשרתי אינטרנט

בשרת אינטרנט, כל בקשה נכנסת יכולה להיחשב כהקשר אסינכרוני נפרד. ניתן להשתמש ב-ALS לאחסון מידע ספציפי לבקשה, כמו מזהה הבקשה, מזהה המשתמש, טוקן אימות ונתונים רלוונטיים אחרים. זה מאפשר גישה נוחה למידע זה מכל חלק ביישום המטפל בבקשה, כולל middleware, בקרים (controllers) ושאילתות למסד הנתונים.

דוגמה (Node.js עם Express):

const express = require('express');
const { AsyncLocalStorage } = require('async_hooks');
const { v4: uuidv4 } = require('uuid');

const app = express();
const asyncLocalStorage = new AsyncLocalStorage();

app.use((req, res, next) => {
  const requestId = uuidv4();
  asyncLocalStorage.run(new Map(), () => {
    asyncLocalStorage.getStore().set('requestId', requestId);
    console.log(`הבקשה ${requestId} החלה`);
    next();
  });
});

app.get('/', (req, res) => {
  const requestId = asyncLocalStorage.getStore().get('requestId');
  console.log(`מטפל בבקשה ${requestId}`);
  res.send(`שלום, מזהה בקשה: ${requestId}`);
});

app.listen(3000, () => {
  console.log('השרת מאזין בפורט 3000');
});

בדוגמה זו, לכל בקשה נכנסת מוקצה מזהה בקשה ייחודי, אשר נשמר ב-Async Local Storage. לאחר מכן ניתן לגשת למזהה זה מכל חלק של מטפל הבקשה, מה שמאפשר לעקוב אחר הבקשה לאורך כל מחזור החיים שלה.

2. ניהול סשנים של משתמשים

ניתן להשתמש ב-ALS גם לניהול סשנים של משתמשים. כאשר משתמש מתחבר, ניתן לאחסן את נתוני הסשן של המשתמש (למשל, מזהה משתמש, תפקידים, הרשאות) ב-ALS. זה מאפשר גישה נוחה לנתוני הסשן של המשתמש מכל חלק ביישום שזקוק להם, מבלי להעביר אותם כארגומנטים.

דוגמה:

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

const asyncLocalStorage = new AsyncLocalStorage();

function authenticateUser(username, password) {
  // הדמיית אימות
  if (username === 'user' && password === 'password') {
    const userSession = { userId: 123, username: 'user', roles: ['admin'] };
    asyncLocalStorage.run(new Map(), () => {
      asyncLocalStorage.getStore().set('userSession', userSession);
      console.log('המשתמש אומת, הסשן נשמר ב-ALS');
      return true;
    });
    return true;
  } else {
    return false;
  }
}

function getUserSession() {
  return asyncLocalStorage.getStore() ? asyncLocalStorage.getStore().get('userSession') : null;
}

function someAsyncOperation() {
  return new Promise(resolve => {
    setTimeout(() => {
      const userSession = getUserSession();
      if (userSession) {
        console.log(`פעולה אסינכרונית: מזהה משתמש: ${userSession.userId}`);
        resolve();
      } else {
        console.log('פעולה אסינכרונית: לא נמצא סשן משתמש');
        resolve();
      }
    }, 100);
  });
}

async function main() {
  if (authenticateUser('user', 'password')) {
    await someAsyncOperation();
  } else {
    console.log('האימות נכשל');
  }
}

main();

בדוגמה זו, לאחר אימות מוצלח, סשן המשתמש נשמר ב-ALS. פונקציית `someAsyncOperation` יכולה אז לגשת לנתוני הסשן הללו מבלי שיהיה צורך להעבירם במפורש כארגומנט.

3. ניהול טרנזקציות

בטרנזקציות של מסדי נתונים, ניתן להשתמש ב-ALS לאחסון אובייקט הטרנזקציה. זה מאפשר גישה לאובייקט הטרנזקציה מכל חלק ביישום המשתתף בטרנזקציה, ומבטיח שכל הפעולות יתבצעו באותו היקף טרנזקציה.

4. רישום לוגים וביקורת (Auditing)

ניתן להשתמש ב-ALS לאחסון מידע ספציפי להקשר למטרות רישום לוגים וביקורת. לדוגמה, ניתן לאחסן את מזהה המשתמש, מזהה הבקשה וחותמת הזמן ב-ALS, ולאחר מכן לכלול מידע זה בהודעות הלוג שלכם. זה מקל על מעקב אחר פעילות המשתמשים וזיהוי בעיות אבטחה פוטנציאליות.

כיצד להשתמש ב-Async Local Storage

השימוש ב-Async Local Storage כולל שלושה שלבים עיקריים:

1. יצירת מופע של AsyncLocalStorage: יוצרים מופע של המחלקה `AsyncLocalStorage`.
2. הרצת קוד בתוך הקשר: משתמשים במתודה `run()` כדי להריץ קוד בתוך הקשר ספציפי. המתודה `run()` מקבלת שני ארגומנטים: מאגר (store, בדרך כלל Map או אובייקט) ופונקציית callback. המאגר יהיה זמין לכל הפעולות האסינכרוניות שנוצרו בתוך פונקציית ה-callback.
3. גישה למאגר: משתמשים במתודה `getStore()` כדי לגשת למאגר מתוך ההקשר האסינכרוני.

דוגמה:

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

const asyncLocalStorage = new AsyncLocalStorage();

function doSomethingAsync() {
  return new Promise(resolve => {
    setTimeout(() => {
      const value = asyncLocalStorage.getStore().get('myKey');
      console.log('ערך מ-ALS:', value);
      resolve();
    }, 500);
  });
}

async function main() {
  asyncLocalStorage.run(new Map(), async () => {
    asyncLocalStorage.getStore().set('myKey', 'שלום מ-ALS!');
    await doSomethingAsync();
  });
}

main();

ה-API של AsyncLocalStorage

מחלקה `AsyncLocalStorage` מספקת את המתודות הבאות:

• constructor(): יוצרת מופע חדש של AsyncLocalStorage.
• run(store, callback, ...args): מריצה את פונקציית ה-callback הנתונה בתוך הקשר שבו המאגר (store) הנתון זמין. המאגר הוא בדרך כלל `Map` או אובייקט JavaScript פשוט. כל הפעולות האסינכרוניות שנוצרו בתוך ה-callback יירשו את ההקשר הזה. ניתן להעביר ארגומנטים נוספים לפונקציית ה-callback.
• getStore(): מחזירה את המאגר הנוכחי עבור ההקשר האסינכרוני הנוכחי. מחזירה `undefined` אם אין מאגר המשויך להקשר הנוכחי.
• disable(): משביתה את מופע ה-AsyncLocalStorage. לאחר ההשבתה, `run()` ו-`getStore()` יפסיקו לתפקד.

שיקולים ושיטות עבודה מומלצות

אף ש-ALS הוא כלי רב-עוצמה, חשוב להשתמש בו בתבונה. הנה כמה שיקולים ושיטות עבודה מומלצות:

• הימנעות משימוש יתר: אל תשתמשו ב-ALS לכל דבר. השתמשו בו רק כאשר אתם צריכים לעקוב אחר הקשר על פני גבולות אסינכרוניים. שקלו פתרונות פשוטים יותר כמו משתנים רגילים אם אין צורך להפיץ את ההקשר דרך קריאות אסינכרוניות.
• ביצועים: אף ש-ALS הוא בדרך כלל יעיל, שימוש מופרז עלול להשפיע על הביצועים. מדדו ובצעו אופטימיזציה לקוד שלכם לפי הצורך. שימו לב לגודל המאגר שאתם מכניסים ל-ALS. אובייקטים גדולים יכולים להשפיע על הביצועים, במיוחד אם נוצרות פעולות אסינכרוניות רבות.
• ניהול הקשר: ודאו שאתם מנהלים כראוי את מחזור החיים של המאגר. צרו מאגר חדש עבור כל בקשה או סשן, ונקו את המאגר כאשר הוא אינו נחוץ עוד. בעוד ש-ALS עצמו עוזר לנהל את ההיקף (scope), הנתונים *בתוך* המאגר עדיין דורשים טיפול נכון ואיסוף זבל (garbage collection).
• טיפול בשגיאות: שימו לב לטיפול בשגיאות. אם מתרחשת שגיאה בתוך פעולה אסינכרונית, ההקשר עלול ללכת לאיבוד. שקלו להשתמש בבלוקי try-catch כדי לטפל בשגיאות ולוודא שההקשר נשמר כראוי.
• ניפוי באגים: ניפוי באגים ביישומים מבוססי ALS יכול להיות מאתגר. השתמשו בכלי ניפוי באגים ורישום לוגים כדי לעקוב אחר זרימת הביצוע ולזהות בעיות פוטנציאליות.
• תאימות: ALS זמין ב-Node.js מגרסה 14.5.0 ואילך. ודאו שהסביבה שלכם תומכת ב-ALS לפני השימוש בו. עבור גרסאות ישנות יותר של Node.js, שקלו להשתמש בפתרונות חלופיים כמו continuation-local storage (CLS), אם כי לאלה עשויים להיות מאפייני ביצועים ו-APIs שונים.

חלופות ל-Async Local Storage

לפני כניסתו של ALS, מפתחים הסתמכו לעתים קרובות על טכניקות אחרות לניהול הקשר ב-JavaScript אסינכרוני. הנה כמה חלופות נפוצות:

• העברת הקשר מפורשת: העברת משתני הקשר כארגומנטים לכל פונקציה בשרשרת הקריאות. גישה זו פשוטה אך עלולה להפוך למייגעת ונוטה לשגיאות ביישומים מורכבים. היא גם מקשה על ריפקטורינג, שכן שינוי נתוני הקשר דורש שינוי בחתימה של פונקציות רבות.
• Continuation-Local Storage (CLS): CLS מספק פונקציונליות דומה ל-ALS, אך הוא מבוסס על מנגנון שונה. CLS משתמש ב-monkey-patching כדי ליירט פעולות אסינכרוניות ולהפיץ את ההקשר. גישה זו יכולה להיות מורכבת יותר ועלולה להיות לה השלכות על הביצועים.
• ספריות ומסגרות עבודה (Frameworks): חלק מהספריות ומסגרות העבודה מספקות מנגנוני ניהול הקשר משלהן. לדוגמה, Express.js מספקת middleware לניהול נתונים ספציפיים לבקשה.

בעוד שחלופות אלה יכולות להיות שימושיות במצבים מסוימים, ALS מציע פתרון אלגנטי ויעיל יותר לניהול הקשר ב-JavaScript אסינכרוני.

סיכום

Async Local Storage (ALS) הוא כלי רב-עוצמה לניהול הקשר ביישומי JavaScript אסינכרוניים. על ידי מתן דרך לאחסן נתונים שהם מקומיים לפעולה אסינכרונית ספציפית, ALS מפשט את ניהול ההקשר, משפר את ניפוי הבאגים ומפחית קוד boilerplate. בין אם אתם בונים שרת אינטרנט, מנהלים סשנים של משתמשים או מטפלים בטרנזקציות של מסד נתונים, ALS יכול לעזור לכם לכתוב קוד נקי, קל יותר לתחזוקה ויעיל יותר.

תכנות אסינכרוני רק הופך נפוץ יותר ויותר ב-JavaScript, מה שהופך את ההבנה של כלים כמו ALS לקריטית יותר. על ידי הבנת השימוש הנכון והמגבלות שלו, מפתחים יכולים ליצור יישומים חזקים וניתנים לניהול המסוגלים להתרחב ולהסתגל לצרכים מגוונים של משתמשים ברחבי העולם. התנסו עם ALS בפרויקטים שלכם וגלו כיצד הוא יכול לפשט את זרימות העבודה האסינכרוניות שלכם ולשפר את ארכיטקטורת היישום הכוללת שלכם.

מקורות נוספים

• תיעוד AsyncLocalStorage של Node.js
• חבילת npm בשם async-local-storage (לגרסאות ישנות של Node.js)
• Async Local Storage ב-Node.js - YouTube