Node.js/NestJS应用中出站HTTP请求的全面审查指南

npm install winston node-fetch
# 或者 yarn add winston node-fetch

// src/utils/logger.ts
import { createLogger, format, transports } from 'winston';

const logger = createLogger({
  level: process.env.NODE_ENV === 'production' ? 'info' : 'debug',
  format: format.combine(
    format.timestamp({ format: 'YYYY-MM-DD HH:mm:ss' }),
    format.json() // 生产环境使用JSON格式日志
  ),
  transports: [
    new transports.Console({
      format: format.combine(
        format.colorize(),
        format.simple() // 开发环境使用简洁格式和颜色
      ),
    }),
    new transports.File({ filename: 'logs/application.log' }), // 将日志写入文件
  ],
});

export default logger;

// src/utils/logged-fetch.ts
import fetch, { RequestInit, Response } from 'node-fetch';
import logger from './logger';

interface LoggedFetchOptions extends RequestInit {
  // 可以添加其他自定义选项
  logBody?: boolean; // 是否记录请求和响应体
}

/**
 * 包装 node-fetch，用于记录出站 HTTP 请求和响应。
 * @param url 请求的URL。
 * @param options 请求选项。
 * @returns Promise<Response>
 */
async function loggedFetch(url: string, options: LoggedFetchOptions = {}): Promise<Response> {
  const requestId = Math.random().toString(36).substring(2, 9); // 生成一个简单的请求ID
  const method = options.method || 'GET';
  const headers = options.headers || {};
  const requestBody = options.body;
  const logBody = options.logBody !== false; // 默认记录请求体

  // 记录请求详情
  logger.info(`[${requestId}] Outgoing Request:`, {
    url,
    method,
    headers: JSON.stringify(headers),
    body: logBody && requestBody ? requestBody.toString() : '[Body Omitted]',
  });

  try {
    const response = await fetch(url, options);
    const responseClone = response.clone(); // 克隆响应以读取其体，而不影响原始流

    // 记录响应详情
    logger.info(`[${requestId}] Incoming Response:`, {
      url,
      method,
      status: response.status,
      statusText: response.statusText,
      responseHeaders: JSON.stringify(Object.fromEntries(response.headers.entries())),
    });

    // 如果需要，异步记录响应体。注意：大响应体可能影响性能。
    if (logBody) {
      responseClone.text().then(body => {
        logger.debug(`[${requestId}] Response Body:`, { body });
      }).catch(err => {
        logger.warn(`[${requestId}] Failed to log response body: ${err.message}`);
      });
    }

    return response;
  } catch (error: any) {
    // 记录请求错误
    logger.error(`[${requestId}] Request Error:`, {
      url,
      method,
      message: error.message,
      stack: error.stack,
    });
    throw error;
  }
}

export default loggedFetch;

// src/external-api/external-api.service.ts
import { Injectable } from '@nestjs/common';
import loggedFetch from '../utils/logged-fetch'; // 导入自定义的fetch函数

@Injectable()
export class ExternalApiService {
  async fetchDataFromExternalApi(): Promise<any> {
    const apiUrl = 'https://api.example.com/data';
    try {
      const response = await loggedFetch(apiUrl, {
        method: 'GET',
        headers: { 'Content-Type': 'application/json' },
        // logBody: true, // 如果需要记录请求和响应体，可以设置为true
      });

      if (!response.ok) {
        throw new Error(`API responded with status ${response.status}`);
      }

      const data = await response.json();
      return data;
    } catch (error) {
      console.error('Error fetching data:', error);
      throw error;
    }
  }

  async postDataToExternalApi(payload: any): Promise<any> {
    const apiUrl = 'https://api.example.com/submit';
    try {
      const response = await loggedFetch(apiUrl, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify(payload),
        // logBody: true,
      });

      if (!response.ok) {
        throw new Error(`API responded with status ${response.status}`);
      }

      const result = await response.json();
      return result;
    } catch (error) {
      console.error('Error posting data:', error);
      throw error;
    }
  }
}