网络调试工具

网络调试工具的基本概念

网络调试工具是开发者在构建、测试和优化网络应用时不可或缺的助手。它们能帮助检查请求与响应、模拟不同网络环境、分析性能瓶颈。对于Node.js开发者来说，这类工具尤其重要，因为Node.js经常被用于构建服务端应用和API。

常见的网络调试工具包括命令行工具如curl、httpie，图形化工具如Postman、Insomnia，以及浏览器开发者工具中的Network面板。Node.js生态中也有专门的库如node-fetch、axios用于发送HTTP请求，winston、morgan用于日志记录。

Node.js内置调试工具

Node.js本身提供了一些基础的网络调试能力。最直接的是console.log，虽然简单但在快速调试时非常有用。更结构化的是util.inspect，它能以更易读的方式输出复杂对象。

const util = require('util');
const obj = {
  name: 'Debug Tool',
  features: ['HTTP', 'WebSocket', 'gRPC'],
  config: { timeout: 5000 }
};
console.log(util.inspect(obj, { depth: null, colors: true }));

对于HTTP服务器，Node.js内置的http模块可以配合net模块进行底层调试。比如创建一个简单的HTTP服务器并记录所有请求：

const http = require('http');

const server = http.createServer((req, res) => {
  console.log(`${req.method} ${req.url}`);
  console.log('Headers:', req.headers);
  req.on('data', chunk => console.log('Body:', chunk.toString()));
  res.end('OK');
});

server.listen(3000);

第三方网络调试库

axios

axios是基于Promise的HTTP客户端，支持拦截请求和响应。它的拦截器功能非常适合调试：

const axios = require('axios');

axios.interceptors.request.use(config => {
  console.log('Request:', config.method.toUpperCase(), config.url);
  return config;
});

axios.interceptors.response.use(response => {
  console.log('Response:', response.status, response.data);
  return response;
});

axios.get('https://api.example.com/data');

node-fetch

node-fetch实现了浏览器fetch API，适合简单的HTTP请求调试：

const fetch = require('node-fetch');

async function debugRequest() {
  const response = await fetch('https://api.example.com/users', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ name: 'John' })
  });
  console.log('Status:', response.status);
  console.log('Headers:', [...response.headers.entries()]);
  console.log('Body:', await response.json());
}

debugRequest();

网络抓包工具

Wireshark与tcpdump

这些底层工具可以捕获网络接口上的所有流量。在Node.js中可以通过child_process模块调用它们：

const { exec } = require('child_process');

// 捕获HTTP流量
exec('tcpdump -i any -A port 80', (error, stdout, stderr) => {
  if (error) {
    console.error(`Error: ${error.message}`);
    return;
  }
  console.log(stdout);
});

mitmproxy

这是一个中间人代理工具，可以拦截、检查和修改HTTP/HTTPS流量。Node.js应用可以通过设置代理来使用它：

const axios = require('axios');

const proxyAxios = axios.create({
  proxy: {
    host: '127.0.0.1',
    port: 8080
  }
});

proxyAxios.get('https://example.com')
  .then(response => console.log(response.data))
  .catch(err => console.error(err));

WebSocket调试工具

Node.js中常用的WebSocket库如ws也提供了调试支持：

const WebSocket = require('ws');

const ws = new WebSocket('wss://echo.websocket.org');

ws.on('open', () => {
  console.log('Connected');
  ws.send('Hello Server');
});

ws.on('message', data => {
  console.log('Received:', data.toString());
});

ws.on('close', () => console.log('Disconnected'));

对于更复杂的WebSocket调试，可以使用wscat命令行工具或浏览器开发者工具中的WebSocket面板。

API测试工具集成

Postman与Newman

Postman的测试集合可以通过Newman在Node.js中运行：

const newman = require('newman');

newman.run({
  collection: require('./api-tests.postman_collection.json'),
  reporters: 'cli'
}, (err, summary) => {
  if (err) throw err;
  console.log('Tests complete!');
});

Supertest

Supertest是专门为测试HTTP API设计的库，特别适合Express应用：

const request = require('supertest');
const app = require('../app');

describe('GET /users', () => {
  it('responds with JSON', done => {
    request(app)
      .get('/users')
      .set('Accept', 'application/json')
      .expect('Content-Type', /json/)
      .expect(200)
      .then(response => {
        console.log(response.body);
        done();
      })
      .catch(done);
  });
});

性能调试工具

autocannon

autocannon是HTTP基准测试工具，可以模拟高并发请求：

const autocannon = require('autocannon');

autocannon({
  url: 'http://localhost:3000',
  connections: 10,
  duration: 10,
  requests: [
    {
      method: 'POST',
      path: '/login',
      body: JSON.stringify({ user: 'test', password: 'test' }),
      headers: { 'Content-Type': 'application/json' }
    }
  ]
}, console.log);

Clinic.js

Clinic.js提供了一套完整的性能诊断工具，包括Doctor、Bubbleprof和Flame：

# 诊断CPU问题
clinic doctor -- node server.js

# 分析异步活动
clinic bubbleprof -- node server.js

# 生成火焰图
clinic flame -- node server.js

日志记录与分析

Winston与Morgan

Winston是灵活的日志库，Morgan专门用于HTTP请求日志：

const winston = require('winston');
const morgan = require('morgan');
const express = require('express');

const logger = winston.createLogger({
  level: 'debug',
  transports: [new winston.transports.Console()]
});

const app = express();
app.use(morgan('combined', { stream: { write: msg => logger.info(msg.trim()) } }));

app.get('/', (req, res) => {
  logger.debug('Handling request');
  res.send('Hello World');
});

app.listen(3000);

ELK Stack集成

将Node.js日志发送到ELK(Elasticsearch, Logstash, Kibana)堆栈：

const { Client } = require('@elastic/elasticsearch');
const winston = require('winston');
const { ElasticsearchTransport } = require('winston-elasticsearch');

const esClient = new Client({ node: 'http://localhost:9200' });

const esTransport = new ElasticsearchTransport({
  level: 'info',
  client: esClient
});

const logger = winston.createLogger({
  transports: [esTransport]
});

logger.info('Application started', { environment: 'development' });

调试代理与中间件

http-proxy-middleware

这个中间件可以用于开发时的API代理，方便调试跨域等问题：

const express = require('express');
const { createProxyMiddleware } = require('http-proxy-middleware');

const app = express();

app.use('/api', createProxyMiddleware({
  target: 'http://api.example.com',
  changeOrigin: true,
  pathRewrite: { '^/api': '' },
  onProxyReq: (proxyReq, req, res) => {
    console.log('Proxying:', req.method, req.path);
  }
}));

app.listen(3000);

node-http-proxy

更底层的HTTP代理实现：

const http = require('http');
const httpProxy = require('http-proxy');

const proxy = httpProxy.createProxyServer();

http.createServer((req, res) => {
  console.log('Proxying request to target');
  proxy.web(req, res, { target: 'http://localhost:8080' });
}).listen(3000);

proxy.on('error', (err, req, res) => {
  console.error('Proxy error:', err);
  res.end();
});

移动端调试工具

ngrok

ngrok可以将本地服务暴露到公网，方便移动端调试：

const ngrok = require('ngrok');
const express = require('express');

const app = express();
app.get('/', (req, res) => res.send('Hello from ngrok!'));

const server = app.listen(3000, async () => {
  const url = await ngrok.connect({
    proto: 'http',
    addr: 3000,
    authtoken: 'your-ngrok-token'
  });
  console.log('Public URL:', url);
});

Flipper

Facebook的Flipper工具可以通过插件支持Node.js调试：

const flipper = require('flipper-server-core');

const server = new flipper.FlipperServer({
  enableAndroid: false,
  enableIOS: false,
  enableDesktop: true
});

server.addPlugin(require('flipper-plugin-network'));
server.start().then(() => console.log('Flipper server started'));

容器环境调试

kubectl与Kubernetes调试

在Kubernetes中调试Node.js应用：

const k8s = require('@kubernetes/client-node');

const kc = new k8s.KubeConfig();
kc.loadFromDefault();

const k8sApi = kc.makeApiClient(k8s.CoreV1Api);

async function getPods() {
  try {
    const res = await k8sApi.listNamespacedPod('default');
    console.log('Pods:', res.body.items.map(pod => pod.metadata.name));
  } catch (err) {
    console.error('Error:', err);
  }
}

getPods();

Docker调试

使用Node.js与Docker API交互：

const Docker = require('dockerode');
const docker = new Docker();

docker.listContainers({ all: true }, (err, containers) => {
  if (err) throw err;
  console.log('Containers:', containers.map(c => c.Names));
});

docker.getContainer('my-app').logs({
  follow: true,
  stdout: true,
  stderr: true
}, (err, stream) => {
  if (err) throw err;
  stream.pipe(process.stdout);
});

安全调试工具

helmet与安全头检查

helmet帮助设置安全相关的HTTP头：

const express = require('express');
const helmet = require('helmet');
const app = express();

app.use(helmet());
app.use(helmet.contentSecurityPolicy({
  directives: {
    defaultSrc: ["'self'"],
    scriptSrc: ["'self'", "'unsafe-inline'"],
    styleSrc: ["'self'", "'unsafe-inline'"]
  }
}));

app.get('/', (req, res) => res.send('Secure app'));
app.listen(3000);

ssl-checker

检查SSL证书信息：

const sslChecker = require('ssl-checker');

async function checkSSL(hostname) {
  try {
    const info = await sslChecker(hostname);
    console.log('SSL Info:', {
      valid: info.valid,
      daysRemaining: info.daysRemaining,
      issuer: info.issuer
    });
  } catch (err) {
    console.error('SSL Check failed:', err);
  }
}

checkSSL('example.com');

实时调试工具

Socket.IO调试

调试Socket.IO连接：

const io = require('socket.io')(3000);

io.on('connection', socket => {
  console.log('Client connected:', socket.id);
  
  socket.on('chat message', msg => {
    console.log('Message:', msg);
    io.emit('chat message', msg);
  });

  socket.on('disconnect', () => {
    console.log('Client disconnected:', socket.id);
  });
});

WebRTC调试

使用simple-peer调试WebRTC连接：

const SimplePeer = require('simple-peer');

const peer1 = new SimplePeer({ initiator: true });
const peer2 = new SimplePeer();

peer1.on('signal', data => peer2.signal(data));
peer2.on('signal', data => peer1.signal(data));

peer1.on('connect', () => {
  console.log('PEER1 connected');
  peer1.send('Hello from peer1');
});

peer2.on('data', data => {
  console.log('PEER2 received:', data.toString());
});