GitHub repo

AsyncLocalStorage in Node.js: Eliminating Context Passing Hell

Modern Node.js applications often struggle with a fundamental challenge: how to pass contextual information (like request IDs, user data, or transaction handles) through deeply nested asynchronous operations without cluttering function signatures. AsyncLocalStorage, introduced in Node.js 12 and stabilized in Node.js 16, provides an elegant solution to this "parameter drilling" problem by creating isolated contexts that persist across the entire async execution chain.

The Context Passing Problem

Traditional approaches to context management in Node.js require explicitly passing parameters through every function in the call chain. Consider a typical Express application where you need to track a request ID for logging purposes:

// Traditional approach - parameter drilling
app.get("/user/:id", async (req, res) => {
  const requestId = req.headers["x-request-id"] || generateId();
  const userData = await fetchUser(req.params.id, requestId);
  const processedData = await processUserData(userData, requestId);
  res.json(processedData);
});

async function fetchUser(userId, requestId) {
  logger.info(`Fetching user ${userId}`, { requestId });
  return await database.findUser(userId, requestId);
}

async function processUserData(userData, requestId) {
  logger.info(`Processing user data`, { requestId });
  return await transformData(userData, requestId);
}

async function transformData(data, requestId) {
  logger.info(`Transforming data`, { requestId });
  // More nested calls requiring requestId...
  return processedData;
}

This pattern becomes unwieldy as applications grow, leading to:

• Verbose function signatures cluttered with context parameters
• Tight coupling between unrelated concerns
• Maintenance overhead when adding new contextual data
• Error-prone parameter passing through deep call stacks

Understanding AsyncLocalStorage

AsyncLocalStorage functions as Node.js's equivalent to Thread-Local Storage in multi-threaded environments, but designed specifically for asynchronous, single-threaded execution. It creates isolated storage contexts that follow the logical flow of asynchronous operations, regardless of callback chains, Promise resolution, or await statements.

Core Concepts

AsyncLocalStorage operates on three fundamental methods:

• run(store, callback): Creates a new context and executes the callback within it
• getStore(): Retrieves the current context from anywhere within the async chain
• enterWith(store): Transitions the current execution context (use sparingly)

The key insight is that AsyncLocalStorage maintains context across await calls, Promise chains, and callback executions, creating a "contextual bubble" that persists throughout the entire request lifecycle.

Elegant Solution with AsyncLocalStorage

Let's examine how AsyncLocalStorage eliminates parameter drilling in the provided Express logger example:

import express from "express";
import { AsyncLocalStorage } from "node:async_hooks";
import { v4 as uuidv4 } from "uuid";
import winston from "winston";

const loggerStorage = new AsyncLocalStorage<winston.Logger>();

// Winston logger setup
const logger = winston.createLogger({
  level: "info",
  transports: [new winston.transports.Console()],
  format: winston.format.combine(
    winston.format.timestamp(),
    winston.format.json(),
  ),
});

// Middleware creates isolated context per request
function loggerMiddleware(
  req: express.Request,
  res: express.Response,
  next: express.NextFunction,
) {
  const reqId = req.header("x-uuid") || uuidv4();
  const reqLogger = logger.child({ reqId }); // Create request-scoped logger

  // Create context bubble for this request
  loggerStorage.run(reqLogger, () => next());
}

// Context retrieval from anywhere in the async chain
function getLogger() {
  return loggerStorage.getStore() || logger;
}

const app = express();

app.use(loggerMiddleware);

app.get("/", async (req: express.Request, res: express.Response) => {
  getLogger().info("Request received", { action: "start" });
  await controller();
  // ... any async work here ...
  res.send("hello world");
});

// Controllers access context without explicit parameters
const controller = async () => {
  getLogger().info("in controller", { action: "start" });
  await nestedService();
};

const nestedService = async () => {
  getLogger().info("in nested service", { action: "processing" });
  // Logger with request ID automatically available!
};

app.listen(3000, () => {
  logger.info("Server is running on port 3000");
});

Architecture Benefits

This implementation provides several architectural advantages:

1. Decoupled Context Management: Business logic remains independent of context handling
2. Zero Parameter Pollution: Function signatures stay clean and focused
3. Automatic Propagation: Context flows through all async operations without manual intervention
4. Isolation Guarantee: Each request maintains its own separate context

Advanced Use Cases

Database Transaction Management

AsyncLocalStorage excels at managing database transactions across multiple repository calls:

import { AsyncLocalStorage } from "async_hooks";
import { Pool } from "pg";

const transactionStorage = new AsyncLocalStorage<any>();
const pool = new Pool();

export async function withTransaction<T>(fn: () => Promise<T>): Promise<T> {
  const client = await pool.connect();
  const trx = await client.query("BEGIN");

  try {
    const result = await transactionStorage.run(client, fn);
    await client.query("COMMIT");
    return result;
  } catch (error) {
    await client.query("ROLLBACK");
    throw error;
  } finally {
    client.release();
  }
}

export function getCurrentTransaction() {
  return transactionStorage.getStore() || pool;
}

// Usage across multiple functions without explicit transaction passing
async function transferMoney(fromId: string, toId: string, amount: number) {
  return withTransaction(async () => {
    await debitAccount(fromId, amount); // Uses transaction automatically
    await creditAccount(toId, amount); // Uses same transaction
    await logTransfer(fromId, toId, amount); // All operations in one transaction
  });
}

async function debitAccount(accountId: string, amount: number) {
  const client = getCurrentTransaction();
  await client.query(
    "UPDATE accounts SET balance = balance - $1 WHERE id = $2",
    [amount, accountId],
  );
}

async function creditAccount(accountId: string, amount: number) {
  const client = getCurrentTransaction();
  await client.query(
    "UPDATE accounts SET balance = balance + $1 WHERE id = $2",
    [amount, accountId],
  );
}

async function logTransfer(fromId: string, toId: string, amount: number) {
  const client = getCurrentTransaction();
  await client.query(
    "INSERT INTO transfers (from_account, to_account, amount) VALUES ($1, $2, $3)",
    [fromId, toId, amount],
  );
}

User Authentication Context

Authentication contexts can be seamlessly propagated without cluttering business logic:

interface User {
  id: string;
  email: string;
  roles: string[];
}

const authStorage = new AsyncLocalStorage<User>();

async function authMiddleware(
  req: express.Request,
  res: express.Response,
  next: express.NextFunction,
) {
  const token = req.headers.authorization?.replace("Bearer ", "");
  if (!token) return next();

  try {
    const user = await authenticateToken(token);
    authStorage.run(user, next);
  } catch (error) {
    res.status(401).json({ error: "Invalid token" });
  }
}

function getCurrentUser(): User | undefined {
  return authStorage.getStore();
}

function requireAuth(): User {
  const user = getCurrentUser();
  if (!user) {
    throw new Error("Authentication required");
  }
  return user;
}

// Business logic accesses user context implicitly
async function getUserProfile() {
  const user = requireAuth();
  return await profileService.getProfile(user.id);
}

async function updateUserProfile(profileData: any) {
  const user = requireAuth();
  if (!user.roles.includes("user")) {
    throw new Error("Insufficient permissions");
  }
  return await profileService.updateProfile(user.id, profileData);
}

Multi-Context Storage Pattern

For complex applications, you can combine multiple AsyncLocalStorage instances:

interface RequestContext {
  requestId: string;
  userAgent: string;
  ip: string;
}

interface UserContext {
  id: string;
  email: string;
  roles: string[];
}

const requestStorage = new AsyncLocalStorage<RequestContext>();
const userStorage = new AsyncLocalStorage<User>();
const loggerStorage = new AsyncLocalStorage<winston.Logger>();

function contextMiddleware(
  req: express.Request,
  res: express.Response,
  next: express.NextFunction,
) {
  const requestId = req.header("x-request-id") || uuidv4();
  const requestContext: RequestContext = {
    requestId,
    userAgent: req.get("User-Agent") || "unknown",
    ip: req.ip,
  };

  const contextLogger = logger.child({
    requestId,
    userAgent: requestContext.userAgent,
    ip: requestContext.ip,
  });

  requestStorage.run(requestContext, () => {
    loggerStorage.run(contextLogger, () => next());
  });
}

// Utility functions to access different contexts
export function getRequestContext(): RequestContext | undefined {
  return requestStorage.getStore();
}

export function getCurrentUser(): User | undefined {
  return userStorage.getStore();
}

export function getLogger(): winston.Logger {
  return loggerStorage.getStore() || logger;
}

// Usage in business logic
async function processBusinessLogic() {
  const context = getRequestContext();
  const user = getCurrentUser();
  const logger = getLogger();

  logger.info("Processing business logic", {
    userId: user?.id,
    requestId: context?.requestId,
  });

  // All nested calls automatically have access to these contexts
  await performDatabaseOperation();
}

Performance Monitoring and Tracing

AsyncLocalStorage enables sophisticated performance monitoring without code instrumentation:

import { performance, PerformanceObserver } from "perf_hooks";

interface TracingContext {
  requestId: string;
  operationStack: string[];
  startTime: number;
}

const tracingStorage = new AsyncLocalStorage<TracingContext>();

const obs = new PerformanceObserver((items) => {
  items.getEntries().forEach((entry) => {
    const context = tracingStorage.getStore();
    if (context) {
      console.log(
        `[${context.requestId}] ${entry.name}: ${entry.duration.toFixed(2)}ms`,
      );
    }
  });
});

obs.observe({ entryTypes: ["measure"], buffered: true });

function withTracing<T>(
  operationName: string,
  fn: () => Promise<T>,
): Promise<T> {
  return new Promise((resolve, reject) => {
    const context = tracingStorage.getStore();
    if (!context) {
      return fn().then(resolve).catch(reject);
    }

    const newContext = {
      ...context,
      operationStack: [...context.operationStack, operationName],
    };

    const startMark = `${operationName}-start-${Date.now()}`;
    const endMark = `${operationName}-end-${Date.now()}`;

    performance.mark(startMark);

    tracingStorage.run(newContext, async () => {
      try {
        const result = await fn();
        performance.mark(endMark);
        performance.measure(operationName, startMark, endMark);
        resolve(result);
      } catch (error) {
        performance.mark(endMark);
        performance.measure(`${operationName} (error)`, startMark, endMark);
        reject(error);
      }
    });
  });
}

// Usage with automatic tracing
async function processRequest(requestId: string) {
  const context: TracingContext = {
    requestId,
    operationStack: [],
    startTime: Date.now(),
  };

  return tracingStorage.run(context, async () => {
    return withTracing("total-request", async () => {
      await withTracing("database-query", () => databaseOperation());
      await withTracing("external-api", () => externalApiCall());
      await withTracing("data-processing", () => processData());
    });
  });
}

Error Handling and Context Loss

AsyncLocalStorage occasionally loses context in specific scenarios. Here's how to handle them:

Common Context Loss Scenarios

import { promisify } from "util";
import { AsyncResource } from "async_hooks";
import fs from "fs";

// 1. Legacy callback-based APIs - Use promisify
const readFileAsync = promisify(fs.readFile);

// 2. Custom Promise implementations - Use AsyncResource
class ContextPreservingTimeout {
  private resource: AsyncResource;

  constructor() {
    this.resource = new AsyncResource("CustomTimeout");
  }

  delay(ms: number): Promise<void> {
    return new Promise((resolve) => {
      // Bind callback to current async context
      const boundResolve = this.resource.bind(resolve);
      setTimeout(boundResolve, ms);
    });
  }
}

// 3. Third-party libraries - Wrap in AsyncResource
function wrapThirdPartyCallback<T>(
  thirdPartyFn: (callback: (error: Error | null, result?: T) => void) => void,
): Promise<T> {
  return new Promise((resolve, reject) => {
    const resource = new AsyncResource("ThirdPartyWrapper");
    const boundResolve = resource.bind(resolve);
    const boundReject = resource.bind(reject);

    thirdPartyFn((error, result) => {
      if (error) {
        boundReject(error);
      } else {
        boundResolve(result!);
      }
    });
  });
}

Context Validation and Debugging

function validateContext() {
  const logger = getLogger();
  const user = getCurrentUser();
  const request = getRequestContext();

  if (!logger) {
    console.warn("Logger context lost!");
  }

  if (!request) {
    console.warn("Request context lost!");
  }

  return { logger, user, request };
}

// Use in critical operations
async function criticalOperation() {
  const { logger, user, request } = validateContext();

  if (!logger || !request) {
    throw new Error("Required context not available");
  }

  logger.info("Executing critical operation", {
    userId: user?.id,
    requestId: request.requestId,
  });
}

Best Practices

1. Limit AsyncLocalStorage Instances

Create one instance per logical concern to avoid confusion:

// Good: Separate concerns
const loggerStorage = new AsyncLocalStorage<winston.Logger>();
const authStorage = new AsyncLocalStorage<User>();
const transactionStorage = new AsyncLocalStorage<DatabaseClient>();

// Avoid: Single storage for everything
const globalStorage = new AsyncLocalStorage<{
  logger: winston.Logger;
  user: User;
  transaction: DatabaseClient;
  // ... grows indefinitely
}>();

2. Provide Fallback Values

Always provide sensible defaults when context is not available:

function getLogger(): winston.Logger {
  return loggerStorage.getStore() || defaultLogger;
}

function getCurrentUser(): User | null {
  return authStorage.getStore() || null;
}

function requireUser(): User {
  const user = getCurrentUser();
  if (!user) {
    throw new UnauthorizedError("Authentication required");
  }
  return user;
}

3. Clean Context Management

Keep contexts minimal and avoid storing large objects:

// Good: Minimal context
interface CleanContext {
  userId: string;
  requestId: string;
  roles: string[];
}

// Avoid: Storing large objects
interface HeavyContext {
  user: CompleteUserObject; // May contain sensitive data
  request: express.Request; // Large object with headers, body, etc.
  database: DatabasePool; // Connection pool
}

4. Testing AsyncLocalStorage

import { describe, it, expect } from "vitest";

describe("AsyncLocalStorage Context", () => {
  it("should maintain context across async operations", async () => {
    const testLogger = logger.child({ test: true });

    await loggerStorage.run(testLogger, async () => {
      expect(getLogger()).toBe(testLogger);

      await new Promise((resolve) => setTimeout(resolve, 10));
      expect(getLogger()).toBe(testLogger);

      await controller();
      expect(getLogger()).toBe(testLogger);
    });
  });

  it("should isolate contexts between concurrent operations", async () => {
    const logger1 = logger.child({ requestId: "req1" });
    const logger2 = logger.child({ requestId: "req2" });

    const results = await Promise.all([
      loggerStorage.run(logger1, async () => {
        await new Promise((resolve) => setTimeout(resolve, 50));
        return getLogger();
      }),
      loggerStorage.run(logger2, async () => {
        await new Promise((resolve) => setTimeout(resolve, 30));
        return getLogger();
      }),
    ]);

    expect(results[0]).toBe(logger1);
    expect(results[1]).toBe(logger2);
  });
});

Performance Considerations

Performance analysis reveals that AsyncLocalStorage introduces minimal overhead in real-world applications:

• Micro-benchmark Impact: Up to 50% overhead in tight loops with no actual work
• Real-world Impact: 2-3% performance decrease in typical web applications
• Memory Overhead: Negligible additional memory usage per context

The performance cost is significantly outweighed by the benefits of cleaner architecture and reduced complexity.

Performance Best Practices

1. Prefer run() over enterWith(): The run() method provides better context isolation
2. Don't create AsyncLocalStorage instances in hot paths: Create them once at module level
3. Avoid storing large objects: Keep context data minimal
4. Use fallbacks: Always provide default values to avoid context lookup overhead when not needed

Integration with Testing

AsyncLocalStorage works seamlessly with testing frameworks:

// Test helper for setting up context
export function withTestContext<T>(
  context: Partial<{ logger: winston.Logger; user: User }>,
  fn: () => Promise<T>,
): Promise<T> {
  return loggerStorage.run(context.logger || testLogger, () => {
    if (context.user) {
      return authStorage.run(context.user, fn);
    }
    return fn();
  });
}

// Usage in tests
describe("User Service", () => {
  it("should process user data with context", async () => {
    const testUser = { id: "123", email: "test@example.com", roles: ["user"] };

    await withTestContext({ user: testUser }, async () => {
      const result = await processUserData();
      expect(result.userId).toBe("123");
    });
  });
});

Security Considerations

AsyncLocalStorage contexts must be handled carefully to prevent information leakage:

Secure Context Management

// Good: Clean, minimal context
interface SecureContext {
  userId: string;
  roles: string[];
  requestId: string;
}

// Bad: Exposes sensitive data
interface InsecureContext {
  user: User; // May contain password hash, email, etc.
  request: express.Request; // Contains headers, body, cookies
  database: Pool; // Database connection with credentials
}

// Safe context extraction
function createSecureUserContext(user: User): SecureContext {
  return {
    userId: user.id,
    roles: user.roles,
    requestId: uuidv4(),
  };
}

Common Pitfalls and Solutions

1. Middleware Order Dependencies

// Wrong: Auth middleware before logger middleware
app.use(authMiddleware);
app.use(loggerMiddleware);

// Correct: Logger middleware first to ensure logging context
app.use(loggerMiddleware);
app.use(authMiddleware);

2. Context Loss in Error Handlers

// Ensure error handlers preserve context
app.use(
  (
    error: Error,
    req: express.Request,
    res: express.Response,
    next: express.NextFunction,
  ) => {
    const logger = getLogger();
    const requestId = getRequestContext()?.requestId;

    logger.error("Request failed", {
      error: error.message,
      stack: error.stack,
      requestId,
    });

    res.status(500).json({ error: "Internal server error", requestId });
  },
);

3. Memory Leaks in Long-Running Operations

// Avoid: Long-running operations that hold context references
async function processLargeDataset() {
  const logger = getLogger(); // This keeps the entire context alive

  for (let i = 0; i < 1000000; i++) {
    // Long-running loop keeps context in memory
    await processItem(i);
  }
}

// Better: Extract needed values early
async function processLargeDataset() {
  const requestId = getRequestContext()?.requestId;
  const localLogger = logger.child({ requestId, operation: "batch-process" });

  for (let i = 0; i < 1000000; i++) {
    localLogger.debug(`Processing item ${i}`);
    await processItem(i);
  }
}

Conclusion

AsyncLocalStorage represents a fundamental shift in how Node.js applications manage contextual data flow. By eliminating parameter drilling and providing automatic context propagation, it enables:

• Cleaner architectures with better separation of concerns
• Improved maintainability through reduced coupling
• Enhanced debugging with consistent request tracing
• Simplified testing with isolated contexts

The technology's minimal performance impact, combined with its powerful capabilities for request tracing, authentication, transaction management, and monitoring, makes it an essential tool for modern Node.js development.

For developers building production Node.js applications, adopting AsyncLocalStorage patterns leads to more robust, debuggable, and maintainable codebases while preserving the performance characteristics that make Node.js attractive for high-throughput applications.

The key to success with AsyncLocalStorage is understanding its async context preservation model, following best practices for context management, and leveraging its power to eliminate the complexity of manual parameter passing through deep async call stacks.