Browser JS:
  window → DevTools (F12) → Console + Sources + Network → EASY

Node.js:
  Terminal → ??? → ??? → ???

Common struggles:
  - "I don't know where the error is"
  - "I can't inspect variables at runtime"
  - "The error stack trace points to node_modules"
  - "It works on my machine but not in production"

app.post('/charge', async (req, res) => {
  const result = await stripe.charges.create(req.body);
  // ⛔ If this throws, there's no error handler!
  // The process crashes. Users lose their orders.
});

DEBUGGING TOOL PYRAMID
════════════════════════

                    ╱╲
                   ╱  ╲
                  ╱ APM ╲          ← Production: Datadog, New Relic
                 ╱────────╲
                ╱  Error   ╲       ← Production: Sentry, Bugsnag
               ╱  Tracking  ╲
              ╱──────────────╲
             ╱   Structured  ╲    ← Production: Winston, Pino
            ╱     Logging     ╲
           ╱────────────────────╲
          ╱   Chrome DevTools    ╲  ← Staging: --inspect
         ╱   Remote Debugging    ╲
        ╱──────────────────────────╲
       ╱      VS Code Debugger      ╲  ← Development: F5
      ╱──────────────────────────────╲
     ╱       console.log/error       ╲  ← Quick prototyping
    ╱──────────────────────────────────╲

flowchart TD
    Start["🐛 Bug Found"] --> Identify["Identify symptoms\nWhat's broken?"]
    Identify --> Reproduce["Reproduce locally"]

    Reproduce --> QuickCheck{"Quick fix?\n(simple typo, missing import)"}
    QuickCheck -->|"Yes"| Fix["Fix it\n(+ write test)"]
    QuickCheck -->|"No"| Debugger["Use debugger"]

    Debugger --> SetBreak["Set breakpoints\nin suspected code"]
    SetBreak --> Run["Run in debug mode\nnode --inspect-brk app.js"]
    Run --> Inspect["Inspect variables,\ncall stack, scope"]
    Inspect --> StepOver["Step through code\n(F10 / F11)"]
    StepOver --> FoundBug["Found the bug?"]

    FoundBug -->|"No"| ChangeSuspect["Change suspicion\nset new breakpoints"]
    ChangeSuspect --> SetBreak

    FoundBug -->|"Yes"| Fix2["Write the fix"]
    Fix2 --> Test["Run tests"]
    Test --> Commit["Commit + PR"]

    Fix --> Commit

    style Start fill:#ef4444,color:#fff
    style Fix fill:#10b981,color:#fff
    style Commit fill:#4f46e5,color:#fff

flowchart LR
    subgraph Node["Node.js Process"]
        App["Your Node.js App"]
        Inspector["V8 Inspector Protocol\n(Chrome DevTools Protocol)"]
        WS["WebSocket Server\nPort 9229"]
    end

    subgraph Client["Debugging Client"]
        Chrome["Chrome DevTools\nchrome://inspect"]
        VSCode["VS Code Debugger"]
        Curl["curl /json/list"]
    end

    App --> Inspector
    Inspector --> WS
    WS <-->|"WebSocket"| Chrome
    WS <-->|"WebSocket"| VSCode
    Curl -->|"HTTP GET"| WS

    style Node fill:#7c3aed,color:#fff
    style Client fill:#059669,color:#fff

flowchart TB
    subgraph App["Application Code"]
        Sync["Sync code\ntry/catch"]
        Async["Async code\n.catch() / try/catch"]
        Promise["Promise rejection\nunhandled"]
    end

    subgraph NodeJS["Node.js Runtime"]
        Uncaught["uncaughtException"]
        Unhandled["unhandledRejection"]
        Warning["Warning\n(deprecation, etc.)"]
    end

    subgraph Logging["Logging Infrastructure"]
        Console["console.error\n(development)"]
        Logger["Structured Logger\n(Winston/Pino)"]
        File["Log File\napp.log"]
    end

    subgraph External["External Monitoring"]
        Sentry["Error Tracking\n(Sentry/Bugsnag)"]
        APM["APM\n(Datadog/New Relic)"]
        Alert["Alerting\n(PagerDuty/Slack)"]
    end

    Sync -->|"caught"| Logger
    Sync -->|"uncaught"| Uncaught
    Async -->|"caught"| Logger
    Async -->|"uncaught"| Unhandled

    Uncaught --> Console
    Unhandled --> Console
    Console --> Logger

    Logger --> File
    Logger --> Sentry
    Sentry --> APM
    APM --> Alert

    style App fill:#4f46e5,color:#fff
    style NodeJS fill:#d97706,color:#fff
    style Logging fill:#059669,color:#fff
    style External fill:#dc2626,color:#fff

sequenceDiagram
    participant Dev as Developer
    participant Terminal as Terminal
    participant Node as Node.js
    participant Chrome as Chrome DevTools

    Dev->>Terminal: node --inspect-brk app.js
    Terminal->>Node: Start Node with inspector
    Node-->>Terminal: Debugger listening on ws://127.0.0.1:9229/...
    Node-->>Terminal: For help, see: https://nodejs.org/en/docs/inspector

    Dev->>Chrome: Open chrome://inspect
    Chrome->>Node: Discover target via /json/list

    Dev->>Chrome: Click "inspect" on Remote Target
    Chrome->>Node: Connect via WebSocket
    Node-->>Chrome: ✅ Connected (paused on first line)

    Dev->>Chrome: Set breakpoint in Sources tab
    Dev->>Chrome: Click "Resume" (F8)
    Node->>Node: Execute until breakpoint
    Node-->>Chrome: ⏸️ Paused at breakpoint

    Dev->>Chrome: Inspect variables in Scope panel
    Dev->>Chrome: Press F10 to step over
    Node->>Node: Execute line by line
    Node-->>Chrome: Updated variable values

    Dev->>Chrome: Press F8 to continue
    Dev->>Chrome: Disconnect debugger

// ─── BUILT-IN DEBUG CONSOLE ───────────────────────
console.log('Simple log');              // Basic output
console.error('Error message');         // stderr (red)
console.warn('Warning');                // stderr (yellow)
console.table([{a: 1}, {a: 2}]);       // Tabular data
console.dir(obj, { depth: null });     // Deep inspect
console.time('label');                  // Start timer
console.timeEnd('label');              // End timer + duration
console.trace('Trace here');           // Print stack trace
console.assert(condition, 'msg');       // Conditional error

// ─── CONSOLE.TABLE ──────────────────────────────────
const users = [
  { id: 1, name: 'Alice', role: 'admin' },
  { id: 2, name: 'Bob', role: 'user' },
  { id: 3, name: 'Charlie', role: 'moderator' },
];

console.table(users, ['id', 'name']);  // Show only id and name columns

// Output:
// ┌─────────┬─────┬───────────┐
// │ (index) │ id  │   name    │
// ├─────────┼─────┼───────────┤
// │    0    │  1  │ 'Alice'   │
// │    1    │  2  │ 'Bob'     │
// │    2    │  3  │ 'Charlie' │
// └─────────┴─────┴───────────┘

// ─── CONSOLE.TIME ───────────────────────────────────
console.time('DB query');
// Simulate database query
setTimeout(() => {
  console.timeEnd('DB query');  // "DB query: 100ms"
}, 100);

// ─── CONSOLE.TRACE ──────────────────────────────────
function getUser(id) {
  if (!id) {
    console.trace('getUser called without id!');
    return null;
  }
  return { id, name: 'Alice' };
}

getUser();  // Shows stack trace: where was this called from?

// src/server.js — Example with debugger statement
const http = require('http');
const logger = require('./utils/logger');

const server = http.createServer((req, res) => {
  // Press F5 in VS Code to start debugging
  // This will pause execution here
  debugger;  // Programmatic breakpoint

  logger.info(`Request: ${req.method} ${req.url}`);

  if (req.url === '/debug') {
    // The debugger is useful here to inspect req object
    // Check: req.headers, req.method, req.url
    res.writeHead(200, { 'Content-Type': 'application/json' });
    res.end(JSON.stringify({ debug: true, headers: req.headers }));
  } else {
    res.writeHead(200);
    res.end('OK');
  }
});

server.listen(3000);

// logger.js — Production-grade structured logging
const pino = require('pino');
const os = require('os');
const { randomUUID } = require('crypto');

// Create a child logger that adds context to every log
const logger = pino({
  level: process.env.LOG_LEVEL || 'info',

  // Pretty print in development, JSON in production
  transport: process.env.NODE_ENV !== 'production'
    ? { target: 'pino-pretty', options: { colorize: true } }
    : undefined,

  // Base fields added to every log entry
  base: {
    pid: process.pid,
    hostname: os.hostname(),
    service: process.env.SERVICE_NAME || 'my-app',
  },

  // Redact sensitive fields
  redact: {
    paths: ['req.headers.authorization', 'req.body.password', 'req.body.ssn'],
    censor: '[REDACTED]',
  },

  // Safe serializers for objects
  serializers: {
    req: pino.stdSerializers.req,
    res: pino.stdSerializers.res,
    err: pino.stdSerializers.err,
  },
});

// ─── USAGE ──────────────────────────────────────────
// Basic logging
logger.info('Server starting');
logger.warn('Deprecated API called: /v1/users');
logger.error({ err: new Error('DB connection failed') }, 'Database error');

// Structured logging (add context objects)
logger.info({
  userId: 123,
  action: 'purchase',
  amount: 49.99,
  currency: 'USD',
}, 'Purchase completed');

// Child loggers with persistent context
const requestLogger = logger.child({
  requestId: randomUUID(),
  endpoint: '/api/users',
});

requestLogger.info('Processing request');
// Output includes: requestId and endpoint in every log

// middleware/request-logger.js — HTTP request logging middleware
function requestLogger(req, res, next) {
  const start = Date.now();

  // Generate unique request ID
  req.id = req.headers['x-request-id'] || randomUUID();
  req.log = logger.child({ requestId: req.id });

  req.log.info({
    method: req.method,
    url: req.url,
    ip: req.ip,
    userAgent: req.headers['user-agent'],
  }, 'Incoming request');

  // Log response when finished
  res.on('finish', () => {
    const duration = Date.now() - start;

    const logLevel = res.statusCode >= 500 ? 'error'
      : res.statusCode >= 400 ? 'warn'
      : 'info';

    req.log[logLevel]({
      statusCode: res.statusCode,
      duration: `${duration}ms`,
      contentLength: res.getHeader('content-length'),
    }, 'Request completed');
  });

  next();
}

// ─── PRODUCTION ERROR HANDLING ──────────────────────
const pino = require('pino');
const Sentry = require('@sentry/node');

// Initialize Sentry
Sentry.init({
  dsn: process.env.SENTRY_DSN,
  environment: process.env.NODE_ENV,
  tracesSampleRate: 0.1,  // Sample 10% of requests
});

const logger = pino();

// ─── 1. GLOBAL UNHANDLED REJECTIONS ───────────────
process.on('unhandledRejection', (reason, promise) => {
  logger.error({
    err: reason instanceof Error ? reason : new Error(String(reason)),
    promise,
  }, 'UNHANDLED PROMISE REJECTION');

  // Send to Sentry
  Sentry.captureException(reason, {
    extra: { type: 'unhandledRejection' },
  });

  // In Node 15+, the process WILL crash
  // Gracefully shut down
  shutdown('unhandledRejection');
});

// ─── 2. GLOBAL UNCAUGHT EXCEPTIONS ─────────────────
process.on('uncaughtException', (err) => {
  logger.error({ err }, 'UNCAUGHT EXCEPTION');

  Sentry.captureException(err, {
    extra: { type: 'uncaughtException' },
  });

  // uncaughtException means the app is in an unstable state
  // Always shutdown after logging!
  shutdown('uncaughtException');
});

// ─── 3. GRACEFUL SHUTDOWN ──────────────────────────
function shutdown(signal) {
  logger.info({ signal }, 'Initiating graceful shutdown');

  // Give pending requests 10 seconds to complete
  server.close(() => {
    logger.info('HTTP server closed');

    // Close database connections
    db.end(() => {
      Sentry.flush(2000).then(() => {
        process.exit(1);  // Exit with error code
      });
    });
  });

  // Force exit after timeout
  setTimeout(() => {
    logger.error('Forced shutdown after timeout');
    process.exit(1);
  }, 10000);
}

// ─── 4. EXPRESS ERROR MIDDLEWARE ───────────────────
app.use((err, req, res, next) => {
  // Log the error
  logger.error({
    err,
    requestId: req.id,
    method: req.method,
    url: req.url,
  }, 'Request error');

  // Send to Sentry with context
  Sentry.withScope((scope) => {
    scope.setUser({ id: req.user?.id });
    scope.setExtra('requestId', req.id);
    scope.setTag('endpoint', req.url);
    Sentry.captureException(err);
  });

  // Don't leak error details to client
  res.status(err.statusCode || 500).json({
    error: process.env.NODE_ENV === 'production'
      ? 'Internal Server Error'
      : err.message,
    requestId: req.id,  // Useful for correlating logs
  });
});

CDP Commands (examples):
{"id":1,"method":"Debugger.enable"}
{"id":2,"method":"Debugger.setBreakpointByUrl","params":{"lineNumber":42,"url":"file:///app/server.js"}}
{"id":3,"method":"Runtime.evaluate","params":{"expression":"JSON.stringify(req.headers)"}}

// ❌ MISTAKE 1: Logging sensitive data
console.log('User:', user);  // ⛔ Might log password, SSN!
logger.info({ user });       // ⛔ Without redact config

// ✅ Use redact in production logger
const logger = pino({ redact: ['user.password', 'user.ssn'] });

// ❌ MISTAKE 2: Not handling promise rejections
app.post('/pay', async (req, res) => {
  const result = await processPayment(req.body);  // ⛔ If throws, crashes!
  res.json(result);
});

// ✅ Always add .catch() for async handlers
app.post('/pay', async (req, res, next) => {
  try {
    const result = await processPayment(req.body);
    res.json(result);
  } catch (err) {
    next(err);  // Pass to Express error handler
  }
});

// ❌ MISTAKE 3: Leaving debugger statements in production
app.get('/data', (req, res) => {
  debugger;  // ⛔ Will pause if inspector is connected!
  res.json(data);
});

// ✅ Use conditional debugger
if (process.env.DEBUG_MODE) debugger;

// ❌ MISTAKE 4: console.log instead of structured logging
console.log('User logged in:', userId);  // Hard to search in logs
logger.info({ userId, event: 'login' }, 'User logged in');  // Searchable

// memory-leak.js — Find the leak!
const http = require('http');

const cache = {};

const server = http.createServer((req, res) => {
  const id = Date.now();

  // This data is NEVER cleaned up
  cache[id] = new Array(1000000).fill('data');

  res.end('OK');
});

server.listen(3000);