Unawaited Promises Cause 40% Data Loss in Node.js

// Node.js 22 LTS — all four error channels demonstrated with realistic examples
// Run with: node errorChannels.js

import { readFile } from 'fs/promises'; // ESM — stable in Node.js 22
import { createReadStream } from 'fs';
import { EventEmitter } from 'events';

// ─────────────────────────────────────────────────────────────────
// CHANNEL 1: Synchronous throw
// Common sources: JSON.parse, URL constructor, Buffer operations,
// synchronous validators, any third-party parser library
// ─────────────────────────────────────────────────────────────────
function parseWebhookPayload(rawBody) {
  // JSON.parse throws synchronously on malformed input
  // Under high load, this is a common event loop blocker if payloads are large
  return JSON.parse(rawBody);
}

try {
  const payload = parseWebhookPayload('{ malformed json }');
} catch (syncError) {
  // syncError is a SyntaxError — we can inspect type and message
  console.log('[Channel 1 - Sync] Caught:', syncError.constructor.name, '-', syncError.message);
}

// ─────────────────────────────────────────────────────────────────
// CHANNEL 2: Error-first callback (the original Node.js pattern)
// Still used by: some core modules via legacy APIs, many npm packages
// pre-2018, child_process, some database drivers
// Note: fs/promises is the modern alternative — prefer it for new code
// ─────────────────────────────────────────────────────────────────
import { readFile as readFileCallback } from 'fs';

readFileCallback('/tmp/file-that-does-not-exist.txt', 'utf8', (callbackError, fileContents) => {
  if (callbackError) {
    // ALWAYS check the first argument
    // ALWAYS return immediately after handling — execution continues otherwise
    // Missing this return causes 'Cannot set headers after they are sent' in Express
    console.log('[Channel 2 - Callback] Caught:', callbackError.code, '-', callbackError.message);
    return; // ← This return is not optional. Treat it as mandatory.
  }
  // Only reaches here if callbackError is null
  console.log('File contents:', fileContents);
});

// ─────────────────────────────────────────────────────────────────
// CHANNEL 3: Promise rejection
// Common sources: fetch(), fs/promises, most modern ORMs and HTTP clients,
// any async function that throws, any explicitly rejected Promise
// In Node.js 22: native fetch() is fully stable — uses this channel
// ─────────────────────────────────────────────────────────────────
async function fetchUserFromDatabase(userId) {
  // Simulates a database call that rejects — e.g. connection timeout
  if (!userId || typeof userId !== 'number') {
    return Promise.reject(new TypeError(`fetchUserFromDatabase expects a number, got: ${typeof userId}`));
  }
  return Promise.reject(new Error(`User ${userId} not found in users table`));
}

async function loadUserProfile(userId) {
  try {
    // Without this try/catch, the rejection becomes UnhandledPromiseRejection
    // In Node.js 22, that exits the process with code 1
    const user = await fetchUserFromDatabase(userId);
    console.log('User loaded:', user);
  } catch (promiseError) {
    console.log('[Channel 3 - Promise] Caught:', promiseError.constructor.name, '-', promiseError.message);
  }
}

await loadUserProfile(42);

// ─────────────────────────────────────────────────────────────────
// CHANNEL 4: EventEmitter 'error' event
// Common sources: streams (ReadStream, WriteStream, Transform),
// net.Socket, http.Server, WebSocket connections, database connection pools
// Rule: attach .on('error') BEFORE calling any methods on the emitter
// ─────────────────────────────────────────────────────────────────
const fileStream = createReadStream('/tmp/nonexistent-large-file.csv');

// If you remove this listener, the error event below crashes the process
// Node.js 22 behaviour is unchanged: no listener = uncaught exception
fileStream.on('error', (streamError) => {
  console.log('[Channel 4 - EventEmitter] Caught:', streamError.code, '-', streamError.message);
});

// The stream will emit 'error' when it tries to open the nonexistent file
// This happens asynchronously — the error arrives after the next I/O cycle

// ─────────────────────────────────────────────────────────────────
// Node.js 22: diagnostics_channel for structured error observability
// This is new and worth knowing — lets you subscribe to error events
// across third-party libraries without modifying their code
// ─────────────────────────────────────────────────────────────────
import diagnostics_channel from 'diagnostics_channel';

const errorChannel = diagnostics_channel.channel('app.error');

// Any code in any library can publish to this channel
// Your error monitoring subscribes once — no monkey-patching required
if (errorChannel.hasSubscribers) {
  errorChannel.subscribe((errorEvent) => {
    // Forward to your observability platform: Sentry, Datadog, OpenTelemetry
    console.log('[DiagnosticsChannel] Error event received:', errorEvent.code);
  });
}

// Publishing to the channel from your error handler:
function publishError(error) {
  if (diagnostics_channel.channel('app.error').hasSubscribers) {
    diagnostics_channel.channel('app.error').publish({
      code: error.errorCode || 'UNKNOWN',
      message: error.message,
      stack: error.stack,
    });
  }
}

// TypeScript — the standard for production Node.js in 2026
// Compile with: tsc or ts-node customErrors.ts

// ─────────────────────────────────────────────────────────────────
// Base application error — all custom errors extend this
// ─────────────────────────────────────────────────────────────────
class AppError extends Error {
  public readonly statusCode: number;
  public readonly errorCode: string;
  public readonly isOperational: boolean;

  constructor(message: string, statusCode: number, errorCode: string) {
    super(message);
    this.name = this.constructor.name; // 'ValidationError', 'DatabaseError', etc.
    this.statusCode = statusCode;       // HTTP status to return to the client
    this.errorCode = errorCode;         // Machine-readable string for programmatic checks
    this.isOperational = true;          // This is a KNOWN error, not a bug

    // Preserves the correct stack trace pointing to the throw site, not this constructor
    // Essential for useful stack traces in production logs
    Error.captureStackTrace(this, this.constructor);
  }
}

// ─────────────────────────────────────────────────────────────────
// Specific error types — each carries its own domain context
// ─────────────────────────────────────────────────────────────────
class ValidationError extends AppError {
  public readonly fieldName: string;
  public readonly receivedValue?: unknown;

  constructor(message: string, fieldName: string, receivedValue?: unknown) {
    super(message, 422, 'VALIDATION_ERROR');
    this.fieldName = fieldName;
    this.receivedValue = receivedValue; // Log this server-side — never send to client
  }
}

class DatabaseError extends AppError {
  public readonly isRetryable: boolean;
  public readonly queryContext?: Record<string, unknown>;

  constructor(message: string, queryContext?: Record<string, unknown>, isRetryable = true) {
    super(message, 503, 'DATABASE_UNAVAILABLE');
    this.isRetryable = isRetryable;
    this.queryContext = queryContext; // The failing operation — log for debugging, never expose to client
  }
}

class NotFoundError extends AppError {
  public readonly resourceType: string;
  public readonly resourceId: string | number;

  constructor(resourceType: string, resourceId: string | number) {
    super(`${resourceType} with ID ${resourceId} was not found`, 404, 'NOT_FOUND');
    this.resourceType = resourceType;
    this.resourceId = resourceId;
  }
}

class RateLimitError extends AppError {
  public readonly retryAfterSeconds: number;

  constructor(retryAfterSeconds: number) {
    super(`Rate limit exceeded. Retry after ${retryAfterSeconds} seconds.`, 429, 'RATE_LIMIT_EXCEEDED');
    this.retryAfterSeconds = retryAfterSeconds;
  }
}

class ExternalServiceError extends AppError {
  public readonly serviceName: string;
  public readonly upstreamStatus?: number;

  constructor(serviceName: string, message: string, upstreamStatus?: number) {
    super(message, 502, 'EXTERNAL_SERVICE_ERROR');
    this.serviceName = serviceName;
    this.upstreamStatus = upstreamStatus; // The HTTP status the upstream returned
  }
}

// ─────────────────────────────────────────────────────────────────
// Simulated service layer — throws typed errors with full context
// ─────────────────────────────────────────────────────────────────
async function createUserAccount(userData: {
  email?: string;
  password?: string;
  username?: string;
}): Promise<{ id: number; email: string }> {

  if (!userData.email || !userData.email.includes('@')) {
    throw new ValidationError(
      'A valid email address is required',
      'email',
      userData.email // Logged server-side for debugging
    );
  }

  if (!userData.password || userData.password.length < 12) {
    throw new ValidationError(
      'Password must be at least 12 characters',
      'password'
      // Do not log the received value for passwords — ever
    );
  }

  // Simulate a database connectivity failure
  const isDatabaseReachable = false;
  if (!isDatabaseReachable) {
    throw new DatabaseError(
      'Primary database is unreachable — connection pool exhausted',
      { operation: 'INSERT', table: 'users', retryStrategy: 'exponential-backoff' },
      true // This is retryable
    );
  }

  return { id: 1001, email: userData.email };
}

// ─────────────────────────────────────────────────────────────────
// Type-safe error handler using instanceof routing
// ─────────────────────────────────────────────────────────────────
async function handleCreateUser(requestBody: Record<string, unknown>): Promise<void> {
  try {
    const user = await createUserAccount(requestBody as any);
    console.log('User created successfully:', user.id);
  } catch (error) {
    if (error instanceof ValidationError) {
      // 422 — user-caused, safe to surface field and message to client
      console.log(`[422] Validation failed — field: '${error.fieldName}', message: ${error.message}`);

    } else if (error instanceof DatabaseError) {
      // 503 — infrastructure failure, do NOT expose queryContext to client
      console.log(`[503] Database error: ${error.message}`);
      console.log(`  Retryable: ${error.isRetryable}`);
      console.log(`  Query context: ${JSON.stringify(error.queryContext)}`);

    } else if (error instanceof ExternalServiceError) {
      // 502 — upstream dependency failed
      console.log(`[502] External service '${error.serviceName}' failed: ${error.message}`);
      console.log(`  Upstream status: ${error.upstreamStatus}`);

    } else if (error instanceof AppError) {
      // Catch-all for any AppError subclass not explicitly handled above
      console.log(`[${error.statusCode}] Application error (${error.errorCode}): ${error.message}`);

    } else {
      // This is a bug — an Error that nobody anticipated
      console.error('[500] Unexpected error — this is a bug that needs investigation:');
      console.error(error);
    }
  }
}

// Test with invalid email
await handleCreateUser({ email: 'not-an-email', password: 'securepassword123!!' });

// Test with weak password
await handleCreateUser({ email: 'user@example.com', password: 'short' });

// Test with database down
await handleCreateUser({ email: 'user@example.com', password: 'securepassword123!!' });

import express, { Request, Response, NextFunction, ErrorRequestHandler } from 'express';
import { randomUUID } from 'crypto';

const app = express();
app.use(express.json({ limit: '1mb' })); // Always set a body size limit

// ─────────────────────────────────────────────────────────────────
// Custom error classes (abbreviated from previous section)
// In a real codebase, import these from a shared errors module
// ─────────────────────────────────────────────────────────────────
class AppError extends Error {
  constructor(
    message: string,
    public readonly statusCode: number,
    public readonly errorCode: string,
    public readonly isOperational = true
  ) {
    super(message);
    this.name = this.constructor.name;
    Error.captureStackTrace(this, this.constructor);
  }
}

class NotFoundError extends AppError {
  constructor(resourceType: string, resourceId: string | number) {
    super(`${resourceType} with id '${resourceId}' does not exist`, 404, 'NOT_FOUND');
  }
}

class ValidationError extends AppError {
  constructor(message: string, public readonly fieldName: string) {
    super(message, 422, 'VALIDATION_ERROR');
  }
}

// ─────────────────────────────────────────────────────────────────
// asyncHandler — the wrapper that makes Express safe for async routes
// Needed for Express 4.x. Not needed in Express 5 (which handles
// Promise rejections natively). Know which version you are on.
// ─────────────────────────────────────────────────────────────────
const asyncHandler = (routeFn: (req: Request, res: Response, next: NextFunction) => Promise<void>) => {
  return (req: Request, res: Response, next: NextFunction): void => {
    Promise.resolve(routeFn(req, res, next)).catch(next);
    // If routeFn rejects, .catch(next) forwards the error to Express error middleware
    // Without this: unhandled rejection → process exits in Node.js 22
  };
};

// ─────────────────────────────────────────────────────────────────
// Request ID middleware — attach before routes, use in error responses
// Gives every request a traceable ID through logs, error responses, and APM
// ─────────────────────────────────────────────────────────────────
app.use((req: Request, res: Response, next: NextFunction) => {
  (req as any).requestId = randomUUID();
  res.setHeader('X-Request-Id', (req as any).requestId);
  next();
});

// ─────────────────────────────────────────────────────────────────
// Simulated data layer
// ─────────────────────────────────────────────────────────────────
const userStore: Record<string, { id: string; name: string; role: string }> = {
  '101': { id: '101', name: 'Alice Nakamura', role: 'admin' },
  '202': { id: '202', name: 'Ben Okafor', role: 'viewer' },
};

async function getUserById(userId: string) {
  const user = userStore[userId];
  if (!user) throw new NotFoundError('User', userId);
  return user;
}

// ─────────────────────────────────────────────────────────────────
// Route handlers — clean, no error formatting here
// Each handler focuses on the happy path and throws typed errors on failure
// ─────────────────────────────────────────────────────────────────
app.get('/users/:userId', asyncHandler(async (req, res) => {
  const user = await getUserById(req.params.userId);
  res.status(200).json({ success: true, data: user });
}));

app.post('/users', asyncHandler(async (req, res) => {
  const { email, name } = req.body;
  if (!email || typeof email !== 'string' || !email.includes('@')) {
    throw new ValidationError('A valid email address is required', 'email');
  }
  // Simulate create — in real code, this is a database call
  const newUser = { id: randomUUID(), name: name || 'Unknown', role: 'viewer' };
  res.status(201).json({ success: true, data: newUser });
}));

// Route that simulates an unexpected bug (non-operational error)
app.get('/debug/crash', asyncHandler(async (_req, _res) => {
  // This represents a genuine bug — accessing a property on undefined, etc.
  throw new Error('Unexpected internal error — this is not an AppError');
}));

// ─────────────────────────────────────────────────────────────────
// Global error handler — MUST be the last app.use() call
// Express identifies this as an error handler via the 4-argument signature
// Express checks function.length at registration — do not use arrow functions
// with default params or rest params as they change .length
// ─────────────────────────────────────────────────────────────────
const globalErrorHandler: ErrorRequestHandler = (err, req, res, _next) => {
  const requestId = (req as any).requestId || 'unknown';
  const timestamp = new Date().toISOString();

  // Always log the full error — operational or not
  console.error(JSON.stringify({
    timestamp,
    requestId,
    errorName: err.name,
    errorCode: err.errorCode || 'UNKNOWN',
    message: err.message,
    statusCode: err.statusCode || 500,
    isOperational: err.isOperational || false,
    stack: err.stack,
    url: req.url,
    method: req.method,
  }));

  if (err.isOperational) {
    // Expected error — respond with structured error, keep process running
    return res.status(err.statusCode).json({
      success: false,
      requestId, // Lets clients correlate error reports with your logs
      error: {
        code: err.errorCode,
        message: err.message,
        // For ValidationError: include the field name so the client knows what to fix
        ...(err.fieldName && { field: err.fieldName }),
      },
    });
  }

  // Non-operational error — this is a bug
  // Respond generically: never leak internal details to clients
  // Alert your on-call team here: Sentry.captureException(err), PagerDuty, etc.
  return res.status(500).json({
    success: false,
    requestId,
    error: {
      code: 'INTERNAL_ERROR',
      message: 'An unexpected error occurred. Our team has been notified.',
    },
  });
};

app.use(globalErrorHandler);

// ─────────────────────────────────────────────────────────────────
// Process-level safety nets — last resort, not primary error handling
// ─────────────────────────────────────────────────────────────────
process.on('unhandledRejection', (reason) => {
  // In Node.js 22, this handler fires before the default process exit
  // Use it to flush logs and alert — do not suppress the exit
  console.error('UNHANDLED_REJECTION:', reason);
  // Sentry.captureException(reason);
});

process.on('uncaughtException', (error) => {
  console.error('UNCAUGHT_EXCEPTION — process will restart:', error.stack);
  // Give logging transports 1 second to flush before exiting
  setTimeout(() => process.exit(1), 1000);
});

app.listen(3000, () => console.log('Server running on port 3000 — Node.js', process.version));

// Node.js 22 LTS — async error patterns with realistic production scenarios

// ─────────────────────────────────────────────────────────────────
// Simulated async operations — replace with your actual data layer calls
// ─────────────────────────────────────────────────────────────────
async function fetchOrderFromDatabase(orderId: number): Promise<{
  id: number; product: string; quantity: number; priceCents: number;
}> {
  if (orderId <= 0) throw new Error(`Invalid order ID: ${orderId}`);
  return { id: orderId, product: 'Wireless Keyboard', quantity: 2, priceCents: 7999 };
}

async function fetchInventoryLevel(productName: string): Promise<{ product: string; available: number }> {
  if (productName === 'Discontinued Item') {
    throw new Error(`No inventory record found for: ${productName}`);
  }
  return { product: productName, available: 150 };
}

async function sendConfirmationEmail(emailAddress: string): Promise<{ sent: boolean; to: string }> {
  if (!emailAddress.includes('@')) {
    throw new Error(`Invalid email address: ${emailAddress}`);
  }
  return { sent: true, to: emailAddress };
}

async function fetchFromPrimaryCache(key: string): Promise<string> {
  throw new Error('Primary cache: connection refused');
}

async function fetchFromSecondaryCache(key: string): Promise<string> {
  return `cached-value-for-${key}`;
}

async function fetchFromDatabase(key: string): Promise<string> {
  return `database-value-for-${key}`;
}

// ─────────────────────────────────────────────────────────────────
// PATTERN 1: Sequential operations — one failure stops the chain
// Use when each step depends on the previous step's result
// ─────────────────────────────────────────────────────────────────
async function processOrderSequentially(orderId: number, customerEmail: string): Promise<void> {
  console.log('\n─── Sequential Processing ───');
  try {
    const order = await fetchOrderFromDatabase(orderId);
    console.log(`Order fetched: ${order.product} x${order.quantity}`);

    const inventory = await fetchInventoryLevel(order.product);
    console.log(`Stock confirmed: ${inventory.available} units available`);

    const emailResult = await sendConfirmationEmail(customerEmail);
    console.log(`Confirmation sent to: ${emailResult.to}`);

  } catch (error) {
    // One catch block handles any step's failure
    // If you need to know WHICH step failed, check error instanceof or error.message
    const message = error instanceof Error ? error.message : String(error);
    console.error(`Order processing failed at step: ${message}`);
    // In production: call next(error) in Express, or rethrow with context
    throw error;
  }
}

// ─────────────────────────────────────────────────────────────────
// PATTERN 2: Promise.allSettled — parallel independent operations
// Use when each result is independent and partial success is acceptable
// Classic use case: dashboards, batch processing, parallel data loading
// ─────────────────────────────────────────────────────────────────
async function loadDashboardData(userId: number): Promise<void> {
  console.log('\n─── Parallel Processing with Promise.allSettled ───');

  // All three requests fire simultaneously — total time = slowest, not sum
  const [ordersResult, inventoryResult, emailResult] = await Promise.allSettled([
    fetchOrderFromDatabase(userId),
    fetchInventoryLevel('Discontinued Item'), // This one will fail
    sendConfirmationEmail('admin@company.com'),
  ]);

  // Handle each result independently — failure in one does not affect others
  if (ordersResult.status === 'fulfilled') {
    console.log('Orders widget: loaded —', ordersResult.value.product);
  } else {
    console.error('Orders widget: failed —', ordersResult.reason.message);
    // Show cached data, a retry button, or an empty state — not a full-page error
  }

  if (inventoryResult.status === 'fulfilled') {
    console.log('Inventory widget: loaded —', inventoryResult.value.available, 'units');
  } else {
    console.warn('Inventory widget: unavailable —', inventoryResult.reason.message);
    // Degrade gracefully: show last known value, grey out the widget
  }

  if (emailResult.status === 'fulfilled') {
    console.log('Email status: sent to', emailResult.value.to);
  } else {
    console.error('Email status: failed —', emailResult.reason.message);
  }
}

// ─────────────────────────────────────────────────────────────────
// PATTERN 3: Promise.any — first success wins, ignore individual failures
// New in Node.js 15, fully standard in Node.js 22
// Use case: redundant sources, geographic fallbacks, cache tier lookups
// ─────────────────────────────────────────────────────────────────
async function fetchWithFallback(cacheKey: string): Promise<string> {
  console.log('\n─── Promise.any — First Success Wins ───');
  try {
    // Try all three sources simultaneously
    // Returns the first one that resolves — ignores failures from the others
    const value = await Promise.any([
      fetchFromPrimaryCache(cacheKey),   // Will fail — connection refused
      fetchFromSecondaryCache(cacheKey), // Will succeed
      fetchFromDatabase(cacheKey),       // Would also succeed, but secondary wins first
    ]);
    console.log('Value retrieved:', value);
    return value;
  } catch (aggregateError) {
    // Only thrown if ALL sources fail — aggregateError.errors has all rejection reasons
    if (aggregateError instanceof AggregateError) {
      console.error('All sources failed:');
      aggregateError.errors.forEach((e: Error, i: number) => {
        console.error(`  Source ${i + 1}: ${e.message}`);
      });
    }
    throw aggregateError;
  }
}

// ─────────────────────────────────────────────────────────────────
// PATTERN 4: The floating Promise — what NOT to do, and the correct fix
// ─────────────────────────────────────────────────────────────────
function demonstrateFloatingPromiseDanger(): void {
  console.log('\n─── Floating Promise Patterns ───');

  // WRONG — the rejection is unhandled. In Node.js 22, this exits the process.
  // fetchOrderFromDatabase(-1); // ← Never do this

  // CORRECT — chain .catch() directly when you cannot await
  fetchOrderFromDatabase(-1).catch((floatingError: Error) => {
    console.error('Caught via .catch():', floatingError.message);
  });

  // CORRECT — use void keyword to explicitly mark fire-and-forget
  // The void keyword tells ESLint no-floating-promises that this is intentional
  void sendConfirmationEmail('not-valid').catch((err: Error) => {
    console.error('Caught fire-and-forget error:', err.message);
  });

  // CORRECT — async IIFE for complex fire-and-forget with try/catch
  (async () => {
    try {
      await sendConfirmationEmail('also-not-valid');
    } catch (iifError: unknown) {
      const message = iifError instanceof Error ? iifError.message : String(iifError);
      console.error('Caught IIFE async error:', message);
    }
  })();
}

// ─────────────────────────────────────────────────────────────────
// Run all patterns
// ─────────────────────────────────────────────────────────────────
(async () => {
  await processOrderSequentially(5, 'customer@shop.com');
  await loadDashboardData(5);
  await fetchWithFallback('user:profile:12345');
  demonstrateFloatingPromiseDanger();
})();

import express from 'express';
import { AsyncLocalStorage } from 'async_hooks'; // Stable in Node.js 22
import { randomUUID } from 'crypto';

const app = express();

// ─────────────────────────────────────────────────────────────────
// AsyncLocalStorage — propagates request context through the entire
// async call stack automatically, including into error handlers
// No prop drilling, no globals, no context passed through every function
// ─────────────────────────────────────────────────────────────────
const requestContext = new AsyncLocalStorage<{ requestId: string; userId?: string }>();

app.use((req, _res, next) => {
  const context = { requestId: randomUUID() };
  // Everything inside this callback — including all async operations it triggers —
  // has access to this context via requestContext.getStore()
  requestContext.run(context, next);
});

// ─────────────────────────────────────────────────────────────────
// Register process-level handlers BEFORE any other code runs
// These are last-resort crash containment — not primary error handling
// ─────────────────────────────────────────────────────────────────
process.on('unhandledRejection', (reason: unknown, promise: Promise<unknown>) => {
  // In Node.js 22, this fires immediately before the default process exit
  // Use it to log with full context, alert, and flush — do not suppress the exit
  const context = requestContext.getStore(); // Works even in async callbacks

  console.error(JSON.stringify({
    event: 'UNHANDLED_REJECTION',
    timestamp: new Date().toISOString(),
    requestId: context?.requestId || 'no-request-context',
    reason: reason instanceof Error ? {
      name: reason.name,
      message: reason.message,
      stack: reason.stack,
    } : String(reason),
  }));

  // Send to your observability platform before the process exits:
  // await Sentry.captureException(reason);
  // await datadogMetrics.increment('app.unhandled_rejection');

  // In Node.js 22, the process exits after this handler regardless.
  // Do NOT call process.exit() here — Node.js 22 handles it.
});

process.on('uncaughtException', (error: Error, origin: string) => {
  // origin is 'uncaughtException' or 'unhandledRejection' (in older Node versions)
  // Node.js 22 passes this to help distinguish the source
  const context = requestContext.getStore();

  console.error(JSON.stringify({
    event: 'UNCAUGHT_EXCEPTION',
    timestamp: new Date().toISOString(),
    origin,
    requestId: context?.requestId || 'no-request-context',
    error: {
      name: error.name,
      message: error.message,
      stack: error.stack,
    },
  }));

  // NEVER attempt to recover and continue after uncaughtException
  // The process state is undefined — memory may be corrupted
  // Give logging transports time to flush, then exit
  // Your process manager (PM2, systemd, K8s) will start a clean instance
  console.error('Process will exit in 1 second to allow log flushing.');
  setTimeout(() => process.exit(1), 1000);
});

// ─────────────────────────────────────────────────────────────────
// Simulate: intentional unhandled rejection for verification
// In a real app, this means you have a floating Promise — fix it
// ─────────────────────────────────────────────────────────────────
async function riskyDatabaseOperation(): Promise<void> {
  throw new Error('Simulated: connection pool exhausted — all 20 connections in use');
}

// Remove the .catch() to see unhandledRejection fire
// This is what a floating Promise looks like in production
setTimeout(() => {
  // With .catch(): caught safely
  riskyDatabaseOperation().catch((err) => {
    console.log('Caught intentionally:', err.message);
  });

  // Without .catch() (commented out to avoid crashing the demo):
  // riskyDatabaseOperation(); // ← This triggers unhandledRejection in Node.js 22
}, 500);

app.get('/health', (_req, res) => {
  res.json({
    status: 'healthy',
    uptime: Math.floor(process.uptime()),
    nodeVersion: process.version,
    memoryMB: Math.round(process.memoryUsage().heapUsed / 1024 / 1024),
  });
});

app.listen(3000, () => {
  console.log(`Server running on port 3000 — Node.js ${process.version}`);
});