深入探究：Node.js 应用中出站 HTTP 请求的监控与调试

import fetch from 'node-fetch';
import { v4 as uuidv4 } from 'uuid'; // 用于生成请求ID，便于追踪

/**
 * 带有日志功能的 fetch 包装器
 * @param {string} url - 请求的 URL
 * @param {object} [options={}] - fetch 请求选项
 * @returns {Promise<Response>} - fetch 响应对象
 */
async function loggedFetch(url, options = {}) {
    const requestId = uuidv4(); // 为每个请求生成唯一ID
    const startTime = Date.now();

    // 默认请求方法为 GET
    const method = options.method ? options.method.toUpperCase() : 'GET';

    // 记录请求开始信息
    console.log(JSON.stringify({
        level: 'INFO',
        timestamp: new Date().toISOString(),
        requestId: requestId,
        type: 'OUTGOING_REQUEST_START',
        method: method,
        url: url,
        headers: options.headers || {}, // 注意：敏感头部信息可能需要脱敏
        bodyPreview: options.body ? options.body.toString().substring(0, 200) + '...' : undefined // 仅记录部分请求体
    }));

    try {
        const response = await fetch(url, options);
        const duration = Date.now() - startTime;

        // 克隆响应以读取其内容，而不影响原始响应流被后续处理使用
        const responseClone = response.clone();
        const responseBodyPreview = await responseClone.text().then(text => text.substring(0, 200) + '...').catch(() => '[Failed to read response body]');

        // 记录请求结束信息
        console.log(JSON.stringify({
            level: 'INFO',
            timestamp: new Date().toISOString(),
            requestId: requestId,
            type: 'OUTGOING_REQUEST_END',
            method: method,
            url: url,
            status: response.status,
            statusText: response.statusText,
            durationMs: duration,
            responseHeaders: response.headers.raw(), // 获取所有响应头部
            responseBodyPreview: responseBodyPreview // 仅记录部分响应体
        }));

        return response;
    } catch (error) {
        const duration = Date.now() - startTime;
        // 记录请求失败信息
        console.error(JSON.stringify({
            level: 'ERROR',
            timestamp: new Date().toISOString(),
            requestId: requestId,
            type: 'OUTGOING_REQUEST_ERROR',
            method: method,
            url: url,
            durationMs: duration,
            errorMessage: error.message,
            errorStack: error.stack // 记录错误堆栈
        }));
        throw error; // 重新抛出错误，保持原有行为
    }
}

// 示例用法：
(async () => {
    try {
        const response = await loggedFetch('https://jsonplaceholder.typicode.com/posts', {
            method: 'POST',
            headers: { 'Content-Type': 'application/json' },
            body: JSON.stringify({
                title: 'foo',
                body: 'bar',
                userId: 1,
            }),
        });
        const data = await response.json();
        console.log('API Response Data:', data);
    } catch (error) {
        console.error('Failed to fetch:', error.message);
    }

    try {
        await loggedFetch('https://httpstat.us/500'); // 模拟一个失败的请求
    } catch (error) {
        console.error('Caught expected error for 500 status.');
    }
})();

// src/common/interceptors/http-logging.interceptor.ts
import { CallHandler, ExecutionContext, Injectable, NestInterceptor } from '@nestjs/common';
import { Observable } from 'rxjs';
import { tap } from 'rxjs/operators';
import { HttpService } from '@nestjs/axios'; // 假设你使用 @nestjs/axios

@Injectable()
export class HttpLoggingInterceptor implements NestInterceptor {
  constructor(private readonly httpService: HttpService) {
    // 注入 HttpService 以便访问其配置，或直接在拦截器中处理
    // 这里我们主要关注拦截 HttpService 发出的请求
    this.httpService.axiosRef.interceptors.request.use(config => {
      const requestId = Math.random().toString(36).substring(7); // 简化生成ID
      (config as any)._requestId = requestId; // 将请求ID附加到配置对象
      console.log(JSON.stringify({
        level: 'INFO',
        timestamp: new Date().toISOString(),
        requestId: requestId,
        type: 'OUTGOING_AXIOS_REQUEST_START',
        method: config.method?.toUpperCase(),
        url: config.url,
        headers: config.headers,
        dataPreview: config.data ? JSON.stringify(config.data).substring(0, 200) + '...' : undefined
      }));
      return config;
    });

    this.httpService.axiosRef.interceptors.response.use(
      response => {
        const requestId = (response.config as any)._requestId;
        console.log(JSON.stringify({
          level: 'INFO',
          timestamp: new Date().toISOString(),
          requestId: requestId,
          type: 'OUTGOING_AXIOS_REQUEST_END',
          method: response.config.method?.toUpperCase(),
          url: response.config.url,
          status: response.status,
          statusText: response.statusText,
          responseHeaders: response.headers,
          dataPreview: response.data ? JSON.stringify(response.data).substring(0, 200) + '...' : undefined
        }));
        return response;
      },
      error => {
        const requestId = (error.config as any)?._requestId;
        console.error(JSON.stringify({
          level: 'ERROR',
          timestamp: new Date().toISOString(),
          requestId: requestId,
          type: 'OUTGOING_AXIOS_REQUEST_ERROR',
          method: error.config?.method?.toUpperCase(),
          url: error.config?.url,
          errorMessage: error.message,
          errorStack: error.stack,
          responseStatus: error.response?.status,
          responseDataPreview: error.response?.data ? JSON.stringify(error.response.data).substring(0, 200) + '...' : undefined
        }));
        return Promise.reject(error);
      },
    );
  }

  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
    // 这个拦截器主要用于处理入站请求，对于出站请求，我们直接在 HttpService 的 axiosRef 上设置拦截器
    // 因此这里可以简单地传递请求，或者根据需要添加额外的逻辑
    return next.handle();
  }
}

// 在 AppModule 或其他模块中注册
// import { Module } from '@nestjs/common';
// import { HttpModule } from '@nestjs/axios';
// import { HttpLoggingInterceptor } from './common/interceptors/http-logging.interceptor';
// import { APP_INTERCEPTOR } from '@nestjs/core';

// @Module({
//   imports: [HttpModule],
//   providers: [
//     {
//       provide: APP_INTERCEPTOR,
//       useClass: HttpLoggingInterceptor,
//     },
//   ],
// })
// export class AppModule {}

// 使用示例：
// 在一个服务中注入 HttpService
// constructor(private readonly httpService: HttpService) {}
// this.httpService.get('https://api.example.com/data').toPromise();