Logging and observability

Overview

Logging and observability at the code level means designing classes so their behavior can be understood in production: structured logs with context (orderId, userId, traceId), appropriate levels (DEBUG, INFO, WARN, ERROR), metrics for counts and latency, and tracing spans around important operations. Good logs explain what happened without a debugger.

Design-wise, logging is a cross-cutting concern: inject a logger interface, use decorators or middleware for common instrumentation, never log secrets or personal data, and keep log statements meaningful. In LLD discussions, mentioning audit logs (who did what), metrics for key actions, and correlation IDs shows production awareness.

When to use it

• Any code running in production.
• Audit requirements (payments, admin actions).
• Debugging intermittent issues and performance.

Where it shows up in interviews

Where it is used in real software

Key terms

Structured logging

Key-value or JSON logs, machine-queryable.

Log levels

DEBUG, INFO, WARN, ERROR by severity.

Correlation ID

ID linking all logs of one request.

Audit log

Immutable record of who did what and when.

PII redaction

Removing personal data from logs.

How it works, step by step

1. 1
   Inject a logger

   Via constructor or a framework factory.

2. 2
   Log events, not narration

   'order placed' with orderId and total.

3. 3
   Choose levels carefully

   ERROR for failures needing attention; INFO for business events.

4. 4
   Attach context

   traceId, userId (not secrets).

5. 5
   Add metrics and spans

   Counters for outcomes, histograms for latency.

Useful vs noisy logs

Payment processing

Structured, contextual, and safe logs turn production debugging from guesswork into queries.

Implementation

1interface Logger {2  info(event: string, fields?: Record<string, unknown>): void;3  error(event: string, fields?: Record<string, unknown>): void;4  child(fields: Record<string, unknown>): Logger;5}6 7const REDACT = new Set(["password", "cardNumber", "token"]);8const jsonLogger = (base: Record<string, unknown> = {}): Logger => {9  const write = (level: string, event: string, fields: Record<string, unknown> = {}) => {10    const safe = Object.fromEntries(Object.entries({ ...base, ...fields }).map(([k, v]) => [k, REDACT.has(k) ? "[redacted]" : v]));11    console.log(JSON.stringify({ ts: new Date().toISOString(), level, event, ...safe }));12  };13  return {14    info: (e, f) => write("info", e, f),15    error: (e, f) => write("error", e, f),16    child: (f) => jsonLogger({ ...base, ...f }),17  };18};19 20class PaymentProcessor {21  constructor(private gateway: PaymentGateway, private log: Logger) {}22  async pay(orderId: string, amountCents: number) {23    const log = this.log.child({ orderId });24    const start = performance.now();25    try {26      const res = await this.gateway.charge(orderId, amountCents);27      log.info("payment_succeeded", { amountCents, ms: Math.round(performance.now() - start) });28      return res;29    } catch (e) {30      log.error("payment_failed", { amountCents, reason: (e as Error).message });31      throw e;32    }33  }34}

Complexity and performance

Trade-offs

Variants and related techniques

Common mistakes

• Logging secrets, tokens, or personal data.

  Fix: Redact centrally and review log fields.

• String concatenation at DEBUG level.

  Fix: Use parameterized logging to avoid building unused strings.

• Logging and rethrowing at every layer.

  Fix: Log once where the error is handled.

Interview questions

Practice problems