Log Errors with Context

Why this matters

An error log that says TypeError: Cannot read properties of undefined (reading 'name') tells you almost nothing. You do not know:

• Which user triggered the error
• What request they made (URL, parameters, body)
• What the application state was at the time
• Whether this is a one-off or affecting hundreds of users
• How to reproduce it

Without this context, debugging is archaeology: you read the stack trace, guess at what data could cause it, search logs for related events, and try to reconstruct the scenario. This turns a 5-minute fix into a multi-hour investigation.

Structured error logs with context make every error immediately actionable. You see the user, the input, the code path, and the state — and you can often reproduce and fix the issue in minutes.

The rule

Every error log must include: (1) a human-readable message, (2) the original error/stack trace, (3) structured context (user ID, request ID, input data, operation name). Use structured logging (JSON) so logs are searchable and filterable.

Bad example

// Useless error logs
try {
  await processOrder(order);
} catch (error) {
  console.log("Error");                    // No details at all
  console.error(error);                    // Stack trace but no context
  console.log("Failed to process order");  // What order? Which user?
}

Good example

import { logger } from "@/lib/logger";
 
try {
  await processOrder(order);
} catch (error) {
  logger.error("Failed to process order", {
    error: error instanceof Error ? {
      message: error.message,
      stack: error.stack,
      name: error.name,
    } : String(error),
    context: {
      userId: auth.userId,
      orderId: order.id,
      orderTotal: order.total,
      paymentMethod: order.paymentMethod,
      requestId: req.headers["x-request-id"],
    },
  });
 
  // Re-throw or return appropriate error to caller
  throw new AppError("ORDER_PROCESSING_FAILED", {
    orderId: order.id,
    cause: error,
  });
}

// lib/logger.ts — structured JSON logger
import pino from "pino";
 
export const logger = pino({
  level: process.env.LOG_LEVEL || "info",
  formatters: {
    level: (label) => ({ level: label }),
  },
  timestamp: pino.stdTimeFunctions.isoTime,
});

How to detect

Search for bare console.error and console.log in catch blocks:

grep -rn 'console\.log\|console\.error' --include="*.ts" --include="*.tsx" | grep -v node_modules

Any console.error(error) without additional context is a finding.

Remediation

1. Install a structured logging library: pino, winston, or tslog
2. Create a shared logger instance with consistent configuration
3. Replace all console.error(error) calls with logger.error(message, { error, context })
4. Add request IDs via middleware so every log entry can be correlated
5. Configure your error tracking service (Sentry, Datadog) to capture the structured context
6. Add user context to error tracking: Sentry.setUser({ id: userId })

References

• Pino: Fast Node.js Logger
• Sentry: Error Context
• 12 Factor App: Logs