Collect diagnostic data:
├── Error Messages (exact text, stack traces)
├── Logs (application, system, network)
├── Reproduction Steps (when, how, conditions)
├── Environment (OS, versions, configuration)
└── Recent Changes (deployments, updates, configs)

Classify the problem:
├── Type (crash, hang, incorrect output, performance)
├── Frequency (always, intermittent, once)
├── Scope (all users, specific users, specific conditions)
├── Timing (immediate, delayed, random)
└── Impact (critical, degraded, cosmetic)

# Strategic logging for investigation
import logging
logging.basicConfig(level=logging.DEBUG)
logger = logging.getLogger(__name__)

def process_order(order):
    logger.debug(f"Processing order: {order.id}")
    logger.debug(f"Order items: {order.items}")
    logger.debug(f"Order total before discount: {order.subtotal}")
    
    try:
        discount = calculate_discount(order)
        logger.debug(f"Calculated discount: {discount}")
    except Exception as e:
        logger.error(f"Discount calculation failed: {e}", exc_info=True)
        raise
    
    final_total = order.subtotal - discount
    logger.debug(f"Final total: {final_total}")
    return final_total

When you have a large codebase or change history:

1. Identify a known-good state (code worked here)
2. Identify the bad state (code broken here)
3. Test the midpoint
4. If broken, search first half; if working, search second half
5. Repeat until you find the breaking change

For git:
$ git bisect start
$ git bisect bad          # Current commit is broken
$ git bisect good abc123  # This commit was working
# Git checks out midpoint, you test, mark good/bad

Explain the problem out loud (to yourself, a duck, or colleague):

1. "I expect this function to return the user's email"
2. "It receives the user_id parameter which is 123"
3. "It queries the database with SELECT email FROM users WHERE id = ..."
4. "Wait - I'm using user_id but the column is called id, not user_id!"

Often the act of explaining reveals the issue.

# Isolate the failing component
def complex_function(data):
    step1_result = step1(data)
    print(f"After step1: {step1_result}")  # Works? ✓
    
    step2_result = step2(step1_result)
    print(f"After step2: {step2_result}")  # Works? ✓
    
    step3_result = step3(step2_result)
    print(f"After step3: {step3_result}")  # FAILS HERE! ✗
    
    return step4(step3_result)

# Now focus investigation on step3

Traceback (most recent call last):
  File "app.py", line 45, in main           # ← Entry point
    result = process_data(data)
  File "processor.py", line 23, in process_data  # ← Called function
    cleaned = clean_input(raw)
  File "utils.py", line 12, in clean_input  # ← Where error occurred
    return data.strip().lower()
AttributeError: 'NoneType' object has no attribute 'strip'
                ↑ The actual error message

TypeError: Cannot read property 'name' of undefined
    at getUserName (user.js:15:22)      // ← Immediate error location
    at displayProfile (profile.js:42:8)  // ← Caller
    at handleClick (app.js:88:3)         // ← Event handler

java.lang.NullPointerException
    at com.app.Service.processUser(Service.java:45)  // ← Error here
    at com.app.Controller.handleRequest(Controller.java:23)
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    ... 23 more  // Internal framework frames, usually ignore

# Use structured logging
[2024-01-15T10:23:45.123Z] [ERROR] [user-123] [order-service] 
  message="Payment failed" 
  order_id=456 
  error_code="CARD_DECLINED"
  duration_ms=2340

# Find errors in last hour
grep "ERROR" app.log | tail -100

# Count error types
grep "ERROR" app.log | awk '{print $4}' | sort | uniq -c | sort -rn

# Find all logs for specific request
grep "request_id=abc123" *.log

# Timeline of events for a user
grep "user_id=456" app.log | sort -k1

# Watch logs in real-time
tail -f app.log | grep --line-buffered "ERROR\|WARN"

1. Get the timestamp of the error
2. Get request/correlation ID if available
3. Search all related services' logs for that ID
4. Build a timeline:
   
   10:23:45.100 [API Gateway] Received request req-123
   10:23:45.150 [User Service] Validating user for req-123
   10:23:45.200 [Order Service] Creating order for req-123
   10:23:45.800 [Payment Service] TIMEOUT processing req-123 ← ROOT CAUSE
   10:23:45.850 [Order Service] Payment failed for req-123
   10:23:45.900 [API Gateway] Returning 500 for req-123

Problem: Application crashed in production

Why? → The database connection pool was exhausted
Why? → Connections weren't being returned to the pool  
Why? → Exception handlers weren't closing connections
Why? → The error handling code was copied without the cleanup
Why? → No code review caught the missing cleanup ← ROOT CAUSE

Fix: Add connection cleanup in finally block + add code review checklist item

                    People           Process
                      │                 │
                      │  Untrained      │  No code review
                      │  developer      │  Poor testing
                      │       ↘         ↙
                       ╔═══════════════════╗
                       ║   APPLICATION     ║
                       ║     CRASH         ║
                       ╚═══════════════════╝
                      │       ↗         ↖
                      │  Missing         │  Legacy 
                      │  logging         │  framework
                      │                  │
                 Technology          Environment

# Simple timing decorator
import time
from functools import wraps

def timed(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        start = time.perf_counter()
        result = func(*args, **kwargs)
        elapsed = time.perf_counter() - start
        print(f"{func.__name__} took {elapsed:.3f}s")
        return result
    return wrapper

@timed
def slow_function():
    # Find what's slow
    pass

# Python CPU profiling
python -m cProfile -s cumtime script.py

# Python memory profiling  
python -m memory_profiler script.py

# Node.js profiling
node --prof app.js
node --prof-process isolate-*.log > profile.txt

# Database query analysis
EXPLAIN ANALYZE SELECT * FROM users WHERE email = 'test@example.com';

# Interactive debugger
python -m pdb script.py

# In code
import pdb; pdb.set_trace()  # Python 3.6
breakpoint()                  # Python 3.7+

# Commands
n     # next line
s     # step into
c     # continue
p var # print variable
l     # list source
w     # where (stack trace)

# Chrome DevTools
node --inspect script.js
# Then open chrome://inspect

# VS Code debugging
# Add launch.json configuration

# In code
debugger;  // Breakpoint when DevTools open

1. Set breakpoint (click line number)
2. Start debug mode (F5 or debug button)
3. When stopped:
   - Inspect variables in watch/locals
   - Step over (F10) - execute line
   - Step into (F11) - enter function
   - Step out (Shift+F11) - exit function
   - Continue (F5) - run to next breakpoint

# Check if service is running
curl -v http://localhost:8080/health

# Test database connectivity
psql -h localhost -U user -d dbname -c "SELECT 1"

# Check port in use
netstat -tlnp | grep 8080  # Linux
lsof -i :8080              # macOS

# Check disk space
df -h

# Check memory
free -h                    # Linux
vm_stat                    # macOS

# Check recent file changes
find . -type f -mmin -30   # Modified in last 30 min

# Check process resource usage
top -p $(pgrep -f "python app.py")