n8n 错误处理指南：打造稳健可靠的自动化工作流

// HTTP节点重试配置示例
{
  "retryOnFail": true,
  "maxTries": 3,
  "timeout": 30000
}

Schedule Trigger → HTTP Request → Data Processing → Database Insert

// 在Function节点中添加API响应验证
const response = $json.response;

// 检查HTTP状态码
if (response.statusCode !== 200) {
// 记录错误详情，便于后续分析
console.error(`API请求失败，状态码：${response.statusCode}，响应：${response.body}`);

// 根据不同的状态码采取不同策略
if (response.statusCode === 429) {
    // 速率限制，建议延迟重试
    return { 
      error: "RATE_LIMITED",
      message: "达到API速率限制",
      retryAfter: response.headers["retry-after"] || 60
    };
  } elseif (response.statusCode >= 500) {
    // 服务器错误，稍后重试
    return { 
      error: "SERVER_ERROR",
      message: "服务器内部错误"
    };
  } else {
    // 其他错误，不需要重试
    thrownewError(`API请求失败: ${response.statusCode}`);
  }
}

// 检查业务逻辑错误
if (response.body && response.body.error) {
thrownewError(`API返回业务错误: ${response.body.error}`);
}

// 返回有效数据
return response.body;

// 数据库写入错误处理
try {
// 尝试执行数据库操作
const result = executeQuery("INSERT INTO table ...");
return result;
} catch (error) {
// 分类处理数据库错误
if (error.code === "ER_DUP_ENTRY") {
    // 重复数据，可能是幂等重试，不视为错误
    console.warn("重复数据，跳过插入");
    return { skipped: true, reason: "DUPLICATE" };
  } elseif (error.code === "ER_DBACCESS_DENIED_ERROR") {
    // 权限错误，需要人工干预
    thrownewError("数据库权限不足");
  } else {
    // 其他数据库错误
    console.error("数据库操作失败:", error.message);
    throw error;
  }
}

Workflow: {{$json["workflow"]["name"]}}<br>
Error: {{$json["execution"]["error"]["message"]}}<br>
Last node executed: {{$json["execution"]["lastNodeExecuted"]}}<br>
Execution URL: {{$json["execution"]["url"]}}<br>
Stacktrace: {{$json["execution"]["error"]["stack"]}}

// 在Function节点中实现指数退避重试
const MAX_RETRIES = 3;
const INITIAL_DELAY = 1000; // 1秒

asyncfunction executeWithRetry(operation, maxRetries = MAX_RETRIES) {
let lastError;

for (let attempt = 0; attempt <= maxRetries; attempt++) {
    try {
      returnawait operation();
    } catch (error) {
      lastError = error;
      
      // 判断是否为可重试错误
      if (!isRetryableError(error) || attempt === maxRetries) {
        break;
      }
      
      // 计算指数退避延迟
      const delay = INITIAL_DELAY * Math.pow(2, attempt);
      console.log(`操作失败，${delay}ms后重试...`);
      awaitnewPromise(resolve => setTimeout(resolve, delay));
    }
  }

throw lastError;
}

function isRetryableError(error) {
// 网络错误、速率限制、服务器错误通常可重试
return error.code === 'ETIMEDOUT' || 
         error.code === 'ECONNRESET' ||
         error.statusCode === 429 ||
         error.statusCode >= 500;
}

// 简单的熔断器实现
class CircuitBreaker {
constructor(failureThreshold, resetTimeout) {
    this.failureThreshold = failureThreshold;
    this.resetTimeout = resetTimeout;
    this.failureCount = 0;
    this.state = 'CLOSED';
    this.nextAttempt = Date.now();
  }

async call(operation) {
    if (this.state === 'OPEN') {
      if (Date.now() < this.nextAttempt) {
        thrownewError('熔断器开启，拒绝请求');
      } else {
        this.state = 'HALF_OPEN';
      }
    }
    
    try {
      const result = await operation();
      this.onSuccess();
      return result;
    } catch (error) {
      this.onFailure();
      throw error;
    }
  }

  onSuccess() {
    this.failureCount = 0;
    this.state = 'CLOSED';
  }

  onFailure() {
    this.failureCount++;
    if (this.failureCount >= this.failureThreshold) {
      this.state = 'OPEN';
      this.nextAttempt = Date.now() + this.resetTimeout;
    }
  }
}

// 补偿事务模式示例
asyncfunction executeTransactionalWorkflow() {
const steps = [
    { execute: reserveInventory, compensate: cancelInventoryReservation },
    { execute: chargePayment, compensate: refundPayment },
    { execute: createShipping, compensate: cancelShipping }
  ];

const completed = [];

try {
    for (const step of steps) {
      const result = await step.execute();
      completed.push(step);
    }
    
    // 所有步骤成功完成
    return { success: true, completed: completed.length };
  } catch (error) {
    console.error("工作流执行失败，开始补偿:", error.message);
    
    // 按相反顺序执行补偿操作
    for (const step of completed.reverse()) {
      try {
        await step.compensate();
      } catch (compensationError) {
        console.error("补偿操作失败:", compensationError);
        // 记录但继续执行其他补偿
      }
    }
    
    thrownewError(`工作流已回滚: ${error.message}`);
  }
}