undefined

深度思考将提供：
- 系统化的假设生成
- 多路径调查策略
- 更深入的模式识别
- 跨领域洞察（例如：网络 + 应用 + 基础设施）

What happened?
- Error message/stack trace
- Frequency (always/intermittent)
- When it started
- Environmental context
- Recent changes

Generate 3-5 plausible hypotheses:

H1: [Most likely cause based on symptoms]
   Evidence for: [...]
   Evidence against: [...]
   Test: [How to validate/invalidate]

H2: [Alternative explanation]
   Evidence for: [...]
   Evidence against: [...]
   Test: [How to validate/invalidate]

H3: [Edge case or rare scenario]
   Evidence for: [...]
   Evidence against: [...]
   Test: [How to validate/invalidate]

Priority order (high to low confidence):
1. Test H1 → Result: [Pass/Fail/Inconclusive]
2. Test H2 → Result: [Pass/Fail/Inconclusive]
3. Test H3 → Result: [Pass/Fail/Inconclusive]

New evidence discovered:
- [Finding 1]
- [Finding 2]

Revised hypotheses if needed:
- [...]

Confirmed root cause: [...]
Contributing factors: [...]
Why it wasn't caught earlier: [...]

Fix implemented: [...]
Tests added: [...]
Validation: [...]
Prevention: [...]

undefined

undefined

undefined

undefined

undefined

undefined

"""
Bug: API endpoint returns 500 error intermittently
Symptoms: 1 in 10 requests fail, always with same user IDs
Hypothesis: Race condition in user data caching
"""

cached = cache.get(cache_key)
if cached:
    logging.debug(f"Cache hit: {cache_key} -> {cached}")
    return cached

user = db.query(User).filter_by(id=user_id).first()
logging.debug(f"DB fetch for user {user_id}: {user}")

cache.set(cache_key, user, timeout=300)
logging.debug(f"Cache set: {cache_key} -> {user}")

return user

undefined

import time
from contextlib import contextmanager

@contextmanager
def debug_timer(operation_name):
    """Time operations and log if slow"""
    start = time.perf_counter()
    try:
        yield
    finally:
        duration = time.perf_counter() - start
        if duration > 1.0:  # Slow operation threshold
            logging.warning(
                f"{operation_name} took {duration:.2f}s",
                extra={'operation': operation_name, 'duration': duration}
            )

undefined

undefined

undefined

import logging

logging.basicConfig(
    level=logging.DEBUG,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    handlers=[
        logging.FileHandler('debug.log'),
        logging.StreamHandler()
    ]
)

logger = logging.getLogger(__name__)

logger.debug("Debug message")
logger.info("Info message")
logger.warning("Warning message")
logger.error("Error message", exc_info=True)

import traceback

try:
    result = risky_operation()
except Exception as e:
    # Log full traceback
    logger.error(f"Operation failed: {e}")
    logger.error(traceback.format_exc())

    # Or get traceback as string
    tb = traceback.format_exception(type(e), e, e.__traceback__)
    error_details = ''.join(tb)

/**
 * Bug: Memory leak in websocket connections
 * Symptoms: Memory grows over time, eventually crashes
 * Hypothesis: Event listeners not cleaned up on disconnect
 */

// H1: Event listeners accumulating
// Test: Track listener counts
class WebSocketManager {
  constructor() {
    this.connections = new Map();
    this.debugListenerCounts = true;
  }

  addConnection(userId, socket) {
    console.debug(`[H1 Test] Adding connection for user ${userId}`);

    if (this.debugListenerCounts) {
      console.debug(`[H1] Listener count before: ${socket.listenerCount('message')}`);
    }

    socket.on('message', (data) => this.handleMessage(userId, data));
    socket.on('close', () => this.removeConnection(userId));

    if (this.debugListenerCounts) {
      console.debug(`[H1] Listener count after: ${socket.listenerCount('message')}`);
    }

    this.connections.set(userId, socket);
  }

  removeConnection(userId) {
    console.debug(`[H1 Test] Removing connection for user ${userId}`);

    const socket = this.connections.get(userId);
    if (socket) {
      const messageListenerCount = socket.listenerCount('message');
      console.debug(`[H1] Listeners still attached: ${messageListenerCount}`);

      // Result: Found 3+ listeners on same event!
      // Root cause: Not removing listeners on reconnect
      socket.removeAllListeners();
      this.connections.delete(userId);
    }
  }
}

// Basic logging
console.log('Basic log');
console.error('Error message');
console.warn('Warning');

// Object inspection with depth
console.dir(object, { depth: null, colors: true });
console.table(array);

// Performance timing
console.time('operation');
// ... code ...
console.timeEnd('operation');

// Memory usage
console.memory; // Chrome only

// Stack trace
console.trace('Trace point');

// Grouping for organized logs
console.group('User Authentication Flow');
console.log('Step 1: Validate credentials');
console.log('Step 2: Generate token');
console.groupEnd();

// Conditional logging
const debug = (label, data) => {
  if (process.env.DEBUG) {
    console.log(`[DEBUG] ${label}:`, JSON.stringify(data, null, 2));
  }
};

// Hypothesis testing helper
function testHypothesis(name, test, expected) {
  console.group(`Testing: ${name}`);
  console.log(`Expected: ${expected}`);
  const actual = test();
  console.log(`Actual: ${actual}`);
  console.log(`Result: ${actual === expected ? 'PASS' : 'FAIL'}`);
  console.groupEnd();
  return actual === expected;
}

// Usage
testHypothesis(
  'H1: Cache returns stale data',
  () => cache.get('key').timestamp,
  Date.now()
);

// Track promise chains
const debugPromise = (label, promise) => {
  console.log(`[${label}] Started`);
  return promise
    .then(result => {
      console.log(`[${label}] Resolved:`, result);
      return result;
    })
    .catch(error => {
      console.error(`[${label}] Rejected:`, error);
      throw error;
    });
};

// Usage
await debugPromise('DB Query', db.users.findOne({ id: 123 }));

// Debugging race conditions
async function debugRaceCondition() {
  const operations = [
    { name: 'Op1', fn: async () => { await delay(100); return 'A'; } },
    { name: 'Op2', fn: async () => { await delay(50); return 'B'; } },
    { name: 'Op3', fn: async () => { await delay(150); return 'C'; } }
  ];

  const results = await Promise.allSettled(
    operations.map(async op => {
      const start = Date.now();
      const result = await op.fn();
      const duration = Date.now() - start;
      console.log(`${op.name} completed in ${duration}ms: ${result}`);
      return { op: op.name, result, duration };
    })
  );

  console.table(results.map(r => r.value));
}

// Debugging memory leaks with weak references
class DebugMemoryLeaks {
  constructor() {
    this.weakMap = new WeakMap();
    this.strongRefs = new Map();
  }

  trackObject(id, obj) {
    // Weak reference - will be GC'd if no other references
    this.weakMap.set(obj, { id, created: Date.now() });

    // Strong reference - prevents GC (potential leak source)
    this.strongRefs.set(id, obj);

    console.log(`Tracking ${id}: Strong refs=${this.strongRefs.size}`);
  }

  release(id) {
    this.strongRefs.delete(id);
    console.log(`Released ${id}: Strong refs=${this.strongRefs.size}`);
  }

  checkLeaks() {
    console.log(`Potential leaks: ${this.strongRefs.size} strong references`);
    return Array.from(this.strongRefs.keys());
  }
}

undefined

undefined

{
  "version": "0.2.0",
  "configurations": [
    {
      "type": "node",
      "request": "launch",
      "name": "Debug Agent",
      "program": "${workspaceFolder}/src/index.js",
      "env": {
        "NODE_ENV": "development"
      }
    }
  ]
}

undefined

undefined

undefined

undefined

undefined

undefined

undefined

undefined

undefined

undefined

undefined

undefined

START: What kind of bug?
│
├─ Known error message/stack trace
│  └─ Use: Direct log analysis + Stack trace walkthrough
│
├─ Intermittent/Race condition
│  └─ Use: Extended thinking + Timeline reconstruction + Hypothesis-driven
│
├─ Performance degradation
│  └─ Use: Profiling + Hypothesis-driven + MECE analysis
│
├─ Distributed system failure
│  └─ Use: Extended thinking + Timeline reconstruction + Multi-system tracing
│
├─ Complex state bug
│  └─ Use: Extended thinking + Hypothesis-driven + pdb/debugger
│
├─ Memory leak
│  └─ Use: Memory profiling + Hypothesis-driven + Weak reference analysis
│
└─ Unknown root cause
   └─ Use: Extended thinking + MECE analysis + 5 Whys

undefined

undefined

AVOID:
- ❌ 同时修改多个内容（无法定位原因）
- ❌ 假设第一个假设是正确的（确认偏差）
- ❌ 无日志/证据调试（猜测）
- ❌ 不记录尝试过的操作（重复失败的尝试）
- ❌ 跳过复现步骤（修复可能无效）

DO:
- ✅ 一次只修改一个变量
- ✅ 系统化测试多个假设
- ✅ 调试前添加监控
- ✅ 保留调查日志
- ✅ 修复后编写回归测试

undefined

    start = time.perf_counter()
    try:
        result = func(*args, **kwargs)
        duration = time.perf_counter() - start
        logger.debug(f"← Exiting {func_name} ({duration:.3f}s)")
        logger.debug(f"  Result: {result}")
        return result
    except Exception as e:
        duration = time.perf_counter() - start
        logger.error(f"✗ Exception in {func_name} ({duration:.3f}s): {e}")
        raise

return wrapper

```javascript
// JavaScript: 全面调试包装器
function debugTrace(label) {
  return function(target, propertyKey, descriptor) {
    const originalMethod = descriptor.value;

    descriptor.value = async function(...args) {
      console.log(`→ Entering ${label || propertyKey}`);
      console.log(`  Args:`, args);

      const start = performance.now();
      try {
        const result = await originalMethod.apply(this, args);
        const duration = performance.now() - start;
        console.log(`← Exiting ${label || propertyKey} (${duration.toFixed(2)}ms)`);
        console.log(`  Result:`, result);
        return result;
      } catch (error) {
        const duration = performance.now() - start;
        console.error(`✗ Exception in ${label || propertyKey} (${duration.toFixed(2)}ms):`, error);
        throw error;
      }
    };

    return descriptor;
  };
}

// Usage
class UserService {
  @debugTrace('UserService.getUser')
  async getUser(userId) {
    // Your code here
  }
}

undefined

undefined

undefined

undefined

1. OBSERVE
   - 收集错误信息、日志、指标
   - 识别模式（频率、条件、范围）
   - 记录症状

2. HYPOTHESIZE（复杂场景下使用深度思考）
   - 生成3-5个合理假设
   - 按可能性排序
   - 为每个假设设计测试

3. TEST
   - 一次只修改一个变量
   - 添加监控（日志、追踪）
   - 收集证据

4. ANALYZE
   - 比较预测与结果
   - 排除无效假设
   - 细化剩余假设

5. FIX
   - 实施解决方案
   - 添加回归测试
   - 记录根因

6. VALIDATE
   - 在受影响环境中验证修复
   - 监控指标
   - 更新文档