高级功能指南

本指南介绍 Trae 的高级功能，帮助您充分利用平台的强大能力。

概述

Trae 提供了许多高级功能，包括自定义工作流、高级调试工具、性能优化、安全配置等。这些功能可以帮助您构建更复杂、更高效的应用程序。

自定义工作流

工作流配置

创建 .trae/workflows/ 目录并添加工作流配置文件：

yaml

# .trae/workflows/ci.yml
name: Continuous Integration

on:
  push:
    branches: [main, develop]
  pull_request:
    branches: [main]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        uses: actions/checkout@v3
        
      - name: Setup Node.js
        uses: actions/setup-node@v3
        with:
          node-version: '18'
          cache: 'npm'
          
      - name: Install dependencies
        run: npm ci
        
      - name: Run tests
        run: npm test
        
      - name: Run linting
        run: npm run lint
        
      - name: Build application
        run: npm run build
        
      - name: Upload coverage
        uses: codecov/codecov-action@v3
        with:
          file: ./coverage/lcov.info

  security:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        uses: actions/checkout@v3
        
      - name: Run security audit
        run: npm audit
        
      - name: Scan for vulnerabilities
        uses: securecodewarrior/github-action-add-sarif@v1
        with:
          sarif-file: security-scan.sarif

  deploy:
    needs: [test, security]
    runs-on: ubuntu-latest
    if: github.ref == 'refs/heads/main'
    steps:
      - name: Deploy to production
        uses: trae/deploy-action@v1
        with:
          environment: production
          api-key: ${{ secrets.TRAE_API_KEY }}

条件执行

yaml

# 基于文件变更的条件执行
steps:
  - name: Check for frontend changes
    id: frontend-changes
    uses: dorny/paths-filter@v2
    with:
      filters: |
        frontend:
          - 'src/frontend/**'
          - 'package.json'
          
  - name: Build frontend
    if: steps.frontend-changes.outputs.frontend == 'true'
    run: npm run build:frontend
    
  - name: Test frontend
    if: steps.frontend-changes.outputs.frontend == 'true'
    run: npm run test:frontend

并行执行

yaml

jobs:
  test:
    strategy:
      matrix:
        node-version: [16, 18, 20]
        os: [ubuntu-latest, windows-latest, macos-latest]
    runs-on: ${{ matrix.os }}
    steps:
      - uses: actions/checkout@v3
      - name: Setup Node.js ${{ matrix.node-version }}
        uses: actions/setup-node@v3
        with:
          node-version: ${{ matrix.node-version }}
      - run: npm ci
      - run: npm test

高级调试工具

远程调试

启用远程调试功能：

javascript

// 在开发环境中启用远程调试
if (process.env.NODE_ENV === 'development') {
  // 启用 Chrome DevTools
  require('inspector').open(9229, '0.0.0.0', true);
  
  // 或使用 VS Code 调试器
  require('inspector').open(9229, 'localhost', false);
}

配置 VS Code 调试：

json

// .vscode/launch.json
{
  "version": "0.2.0",
  "configurations": [
    {
      "name": "Attach to Trae",
      "type": "node",
      "request": "attach",
      "port": 9229,
      "address": "localhost",
      "localRoot": "${workspaceFolder}",
      "remoteRoot": "/app",
      "protocol": "inspector"
    },
    {
      "name": "Debug Trae App",
      "type": "node",
      "request": "launch",
      "program": "${workspaceFolder}/src/index.js",
      "env": {
        "NODE_ENV": "development",
        "DEBUG": "trae:*"
      },
      "console": "integratedTerminal",
      "internalConsoleOptions": "neverOpen"
    }
  ]
}

性能分析

javascript

// 性能监控中间件
const performanceMonitor = (req, res, next) => {
  const start = process.hrtime.bigint();
  
  res.on('finish', () => {
    const end = process.hrtime.bigint();
    const duration = Number(end - start) / 1000000; // 转换为毫秒
    
    console.log(`${req.method} ${req.url} - ${res.statusCode} - ${duration.toFixed(2)}ms`);
    
    // 记录慢请求
    if (duration > 1000) {
      console.warn(`Slow request detected: ${req.method} ${req.url} took ${duration.toFixed(2)}ms`);
    }
  });
  
  next();
};

app.use(performanceMonitor);

内存分析

javascript

// 内存使用监控
const monitorMemory = () => {
  const usage = process.memoryUsage();
  
  console.log('Memory Usage:');
  console.log(`- RSS: ${Math.round(usage.rss / 1024 / 1024)} MB`);
  console.log(`- Heap Total: ${Math.round(usage.heapTotal / 1024 / 1024)} MB`);
  console.log(`- Heap Used: ${Math.round(usage.heapUsed / 1024 / 1024)} MB`);
  console.log(`- External: ${Math.round(usage.external / 1024 / 1024)} MB`);
  
  // 检查内存泄漏
  if (usage.heapUsed > 500 * 1024 * 1024) { // 500MB
    console.warn('High memory usage detected!');
  }
};

// 每分钟检查一次内存使用
setInterval(monitorMemory, 60000);

性能优化

代码分割

javascript

// 动态导入实现代码分割
const loadComponent = async (componentName) => {
  try {
    const module = await import(`./components/${componentName}`);
    return module.default;
  } catch (error) {
    console.error(`Failed to load component: ${componentName}`, error);
    return null;
  }
};

// React 中的懒加载
import { lazy, Suspense } from 'react';

const LazyComponent = lazy(() => import('./HeavyComponent'));

function App() {
  return (
    <div>
      <Suspense fallback={<div>Loading...</div>}>
        <LazyComponent />
      </Suspense>
    </div>
  );
}

缓存策略

javascript

// Redis 缓存实现
const redis = require('redis');
const client = redis.createClient();

class CacheManager {
  async get(key) {
    try {
      const value = await client.get(key);
      return value ? JSON.parse(value) : null;
    } catch (error) {
      console.error('Cache get error:', error);
      return null;
    }
  }
  
  async set(key, value, ttl = 3600) {
    try {
      await client.setex(key, ttl, JSON.stringify(value));
    } catch (error) {
      console.error('Cache set error:', error);
    }
  }
  
  async del(key) {
    try {
      await client.del(key);
    } catch (error) {
      console.error('Cache delete error:', error);
    }
  }
  
  async flush() {
    try {
      await client.flushall();
    } catch (error) {
      console.error('Cache flush error:', error);
    }
  }
}

const cache = new CacheManager();

// 缓存中间件
const cacheMiddleware = (ttl = 3600) => {
  return async (req, res, next) => {
    const key = `cache:${req.method}:${req.originalUrl}`;
    
    try {
      const cached = await cache.get(key);
      
      if (cached) {
        return res.json(cached);
      }
      
      // 重写 res.json 以缓存响应
      const originalJson = res.json;
      res.json = function(data) {
        cache.set(key, data, ttl);
        return originalJson.call(this, data);
      };
      
      next();
    } catch (error) {
      console.error('Cache middleware error:', error);
      next();
    }
  };
};

// 使用缓存
app.get('/api/data', cacheMiddleware(1800), (req, res) => {
  // 这个响应会被缓存 30 分钟
  res.json({ data: 'expensive operation result' });
});

数据库优化

javascript

// 数据库连接池
const { Pool } = require('pg');

const pool = new Pool({
  host: process.env.DB_HOST,
  port: process.env.DB_PORT,
  database: process.env.DB_NAME,
  user: process.env.DB_USER,
  password: process.env.DB_PASSWORD,
  max: 20, // 最大连接数
  idleTimeoutMillis: 30000,
  connectionTimeoutMillis: 2000,
});

// 查询优化
class DatabaseManager {
  async query(text, params) {
    const start = Date.now();
    const client = await pool.connect();
    
    try {
      const result = await client.query(text, params);
      const duration = Date.now() - start;
      
      console.log('Executed query', { text, duration, rows: result.rowCount });
      
      // 记录慢查询
      if (duration > 1000) {
        console.warn('Slow query detected:', { text, duration });
      }
      
      return result;
    } finally {
      client.release();
    }
  }
  
  // 批量插入优化
  async batchInsert(table, columns, data) {
    if (!data.length) return;
    
    const values = data.map((row, index) => {
      const rowValues = columns.map((_, colIndex) => `$${index * columns.length + colIndex + 1}`);
      return `(${rowValues.join(', ')})`;
    }).join(', ');
    
    const query = `INSERT INTO ${table} (${columns.join(', ')}) VALUES ${values}`;
    const params = data.flat();
    
    return this.query(query, params);
  }
  
  // 分页查询
  async paginate(table, options = {}) {
    const {
      page = 1,
      limit = 10,
      where = '',
      orderBy = 'id',
      orderDirection = 'ASC'
    } = options;
    
    const offset = (page - 1) * limit;
    
    const countQuery = `SELECT COUNT(*) FROM ${table} ${where}`;
    const dataQuery = `
      SELECT * FROM ${table} 
      ${where} 
      ORDER BY ${orderBy} ${orderDirection} 
      LIMIT $1 OFFSET $2
    `;
    
    const [countResult, dataResult] = await Promise.all([
      this.query(countQuery),
      this.query(dataQuery, [limit, offset])
    ]);
    
    const total = parseInt(countResult.rows[0].count);
    const totalPages = Math.ceil(total / limit);
    
    return {
      data: dataResult.rows,
      pagination: {
        page,
        limit,
        total,
        totalPages,
        hasNext: page < totalPages,
        hasPrev: page > 1
      }
    };
  }
}

const db = new DatabaseManager();

安全配置

身份验证和授权

javascript

// JWT 令牌管理
const jwt = require('jsonwebtoken');
const bcrypt = require('bcrypt');

class AuthManager {
  constructor() {
    this.jwtSecret = process.env.JWT_SECRET;
    this.jwtExpiry = process.env.JWT_EXPIRY || '1h';
    this.refreshSecret = process.env.REFRESH_SECRET;
    this.refreshExpiry = process.env.REFRESH_EXPIRY || '7d';
  }
  
  async hashPassword(password) {
    const saltRounds = 12;
    return bcrypt.hash(password, saltRounds);
  }
  
  async verifyPassword(password, hash) {
    return bcrypt.compare(password, hash);
  }
  
  generateTokens(payload) {
    const accessToken = jwt.sign(payload, this.jwtSecret, {
      expiresIn: this.jwtExpiry,
      issuer: 'trae-app',
      audience: 'trae-users'
    });
    
    const refreshToken = jwt.sign(payload, this.refreshSecret, {
      expiresIn: this.refreshExpiry,
      issuer: 'trae-app',
      audience: 'trae-users'
    });
    
    return { accessToken, refreshToken };
  }
  
  verifyAccessToken(token) {
    try {
      return jwt.verify(token, this.jwtSecret, {
        issuer: 'trae-app',
        audience: 'trae-users'
      });
    } catch (error) {
      throw new Error('Invalid access token');
    }
  }
  
  verifyRefreshToken(token) {
    try {
      return jwt.verify(token, this.refreshSecret, {
        issuer: 'trae-app',
        audience: 'trae-users'
      });
    } catch (error) {
      throw new Error('Invalid refresh token');
    }
  }
}

const auth = new AuthManager();

// 认证中间件
const authenticateToken = async (req, res, next) => {
  const authHeader = req.headers['authorization'];
  const token = authHeader && authHeader.split(' ')[1];
  
  if (!token) {
    return res.status(401).json({ error: 'Access token required' });
  }
  
  try {
    const decoded = auth.verifyAccessToken(token);
    req.user = decoded;
    next();
  } catch (error) {
    return res.status(403).json({ error: 'Invalid or expired token' });
  }
};

// 权限检查中间件
const requirePermission = (permission) => {
  return (req, res, next) => {
    if (!req.user) {
      return res.status(401).json({ error: 'Authentication required' });
    }
    
    if (!req.user.permissions || !req.user.permissions.includes(permission)) {
      return res.status(403).json({ error: 'Insufficient permissions' });
    }
    
    next();
  };
};

// 角色检查中间件
const requireRole = (roles) => {
  return (req, res, next) => {
    if (!req.user) {
      return res.status(401).json({ error: 'Authentication required' });
    }
    
    const userRoles = Array.isArray(req.user.roles) ? req.user.roles : [req.user.role];
    const requiredRoles = Array.isArray(roles) ? roles : [roles];
    
    const hasRole = requiredRoles.some(role => userRoles.includes(role));
    
    if (!hasRole) {
      return res.status(403).json({ error: 'Insufficient role permissions' });
    }
    
    next();
  };
};

安全头和 CORS

javascript

const helmet = require('helmet');
const cors = require('cors');

// 安全头配置
app.use(helmet({
  contentSecurityPolicy: {
    directives: {
      defaultSrc: ["'self'"],
      styleSrc: ["'self'", "'unsafe-inline'", 'https://fonts.googleapis.com'],
      fontSrc: ["'self'", 'https://fonts.gstatic.com'],
      imgSrc: ["'self'", 'data:', 'https:'],
      scriptSrc: ["'self'"],
      connectSrc: ["'self'", 'https://api.trae.ai'],
      frameSrc: ["'none'"],
      objectSrc: ["'none'"],
      upgradeInsecureRequests: [],
    },
  },
  hsts: {
    maxAge: 31536000,
    includeSubDomains: true,
    preload: true
  }
}));

// CORS 配置
const corsOptions = {
  origin: (origin, callback) => {
    const allowedOrigins = process.env.ALLOWED_ORIGINS?.split(',') || ['http://localhost:3000'];
    
    if (!origin || allowedOrigins.includes(origin)) {
      callback(null, true);
    } else {
      callback(new Error('Not allowed by CORS'));
    }
  },
  credentials: true,
  optionsSuccessStatus: 200,
  methods: ['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS'],
  allowedHeaders: ['Content-Type', 'Authorization', 'X-Requested-With']
};

app.use(cors(corsOptions));

输入验证和清理

javascript

const Joi = require('joi');
const DOMPurify = require('isomorphic-dompurify');

// 输入验证中间件
const validateInput = (schema) => {
  return (req, res, next) => {
    const { error, value } = schema.validate(req.body, {
      abortEarly: false,
      stripUnknown: true
    });
    
    if (error) {
      const errors = error.details.map(detail => ({
        field: detail.path.join('.'),
        message: detail.message
      }));
      
      return res.status(400).json({
        error: 'Validation failed',
        details: errors
      });
    }
    
    req.body = value;
    next();
  };
};

// 验证模式
const userSchema = Joi.object({
  username: Joi.string().alphanum().min(3).max(30).required(),
  email: Joi.string().email().required(),
  password: Joi.string().min(8).pattern(new RegExp('^(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.*[!@#\$%\^&\*])')).required(),
  fullName: Joi.string().min(2).max(100).required(),
  age: Joi.number().integer().min(13).max(120),
  bio: Joi.string().max(500).optional()
});

// HTML 清理中间件
const sanitizeHtml = (req, res, next) => {
  const sanitizeValue = (value) => {
    if (typeof value === 'string') {
      return DOMPurify.sanitize(value);
    }
    if (typeof value === 'object' && value !== null) {
      const sanitized = {};
      for (const [key, val] of Object.entries(value)) {
        sanitized[key] = sanitizeValue(val);
      }
      return sanitized;
    }
    return value;
  };
  
  req.body = sanitizeValue(req.body);
  req.query = sanitizeValue(req.query);
  
  next();
};

// 使用示例
app.post('/api/users', 
  sanitizeHtml,
  validateInput(userSchema),
  authenticateToken,
  requirePermission('user:create'),
  async (req, res) => {
    // 处理用户创建
  }
);

监控和日志

结构化日志

javascript

const winston = require('winston');
const { ElasticsearchTransport } = require('winston-elasticsearch');

// 日志配置
const logger = winston.createLogger({
  level: process.env.LOG_LEVEL || 'info',
  format: winston.format.combine(
    winston.format.timestamp(),
    winston.format.errors({ stack: true }),
    winston.format.json()
  ),
  defaultMeta: {
    service: 'trae-app',
    version: process.env.APP_VERSION || '1.0.0',
    environment: process.env.NODE_ENV || 'development'
  },
  transports: [
    new winston.transports.File({ 
      filename: 'logs/error.log', 
      level: 'error' 
    }),
    new winston.transports.File({ 
      filename: 'logs/combined.log' 
    }),
    new winston.transports.Console({
      format: winston.format.combine(
        winston.format.colorize(),
        winston.format.simple()
      )
    })
  ]
});

// 生产环境添加 Elasticsearch 传输
if (process.env.NODE_ENV === 'production') {
  logger.add(new ElasticsearchTransport({
    level: 'info',
    clientOpts: {
      node: process.env.ELASTICSEARCH_URL
    },
    index: 'trae-logs'
  }));
}

// 请求日志中间件
const requestLogger = (req, res, next) => {
  const start = Date.now();
  
  res.on('finish', () => {
    const duration = Date.now() - start;
    
    logger.info('HTTP Request', {
      method: req.method,
      url: req.url,
      statusCode: res.statusCode,
      duration,
      userAgent: req.get('User-Agent'),
      ip: req.ip,
      userId: req.user?.id
    });
  });
  
  next();
};

app.use(requestLogger);

应用监控

javascript

const prometheus = require('prom-client');

// 创建指标
const httpRequestDuration = new prometheus.Histogram({
  name: 'http_request_duration_seconds',
  help: 'Duration of HTTP requests in seconds',
  labelNames: ['method', 'route', 'status_code'],
  buckets: [0.1, 0.5, 1, 2, 5]
});

const httpRequestTotal = new prometheus.Counter({
  name: 'http_requests_total',
  help: 'Total number of HTTP requests',
  labelNames: ['method', 'route', 'status_code']
});

const activeConnections = new prometheus.Gauge({
  name: 'active_connections',
  help: 'Number of active connections'
});

// 监控中间件
const metricsMiddleware = (req, res, next) => {
  const start = Date.now();
  
  activeConnections.inc();
  
  res.on('finish', () => {
    const duration = (Date.now() - start) / 1000;
    const route = req.route?.path || req.path;
    
    httpRequestDuration
      .labels(req.method, route, res.statusCode)
      .observe(duration);
      
    httpRequestTotal
      .labels(req.method, route, res.statusCode)
      .inc();
      
    activeConnections.dec();
  });
  
  next();
};

app.use(metricsMiddleware);

// 指标端点
app.get('/metrics', async (req, res) => {
  res.set('Content-Type', prometheus.register.contentType);
  res.end(await prometheus.register.metrics());
});

部署策略

蓝绿部署

yaml

# .trae/deployment/blue-green.yml
apiVersion: v1
kind: ConfigMap
metadata:
  name: deployment-config
data:
  strategy: blue-green
  healthcheck_path: /health
  healthcheck_timeout: 30s
  traffic_split_duration: 300s
  rollback_threshold: 5%

---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: app-blue
  labels:
    app: myapp
    version: blue
spec:
  replicas: 3
  selector:
    matchLabels:
      app: myapp
      version: blue
  template:
    metadata:
      labels:
        app: myapp
        version: blue
    spec:
      containers:
      - name: app
        image: myapp:latest
        ports:
        - containerPort: 3000
        livenessProbe:
          httpGet:
            path: /health
            port: 3000
          initialDelaySeconds: 30
          periodSeconds: 10
        readinessProbe:
          httpGet:
            path: /ready
            port: 3000
          initialDelaySeconds: 5
          periodSeconds: 5

---
apiVersion: v1
kind: Service
metadata:
  name: app-service
spec:
  selector:
    app: myapp
    version: blue  # 切换到 green 进行部署
  ports:
  - port: 80
    targetPort: 3000
  type: LoadBalancer

金丝雀部署

javascript

// 金丝雀部署配置
const canaryConfig = {
  enabled: process.env.CANARY_ENABLED === 'true',
  percentage: parseInt(process.env.CANARY_PERCENTAGE) || 10,
  duration: parseInt(process.env.CANARY_DURATION) || 3600, // 1小时
  metrics: {
    errorRateThreshold: 0.05, // 5%
    responseTimeThreshold: 2000, // 2秒
    minRequests: 100
  }
};

// 金丝雀路由中间件
const canaryRouter = (req, res, next) => {
  if (!canaryConfig.enabled) {
    return next();
  }
  
  // 基于用户 ID 的一致性哈希
  const userId = req.user?.id || req.ip;
  const hash = require('crypto').createHash('md5').update(userId).digest('hex');
  const hashValue = parseInt(hash.substring(0, 8), 16);
  const percentage = (hashValue % 100) + 1;
  
  if (percentage <= canaryConfig.percentage) {
    req.canary = true;
    res.setHeader('X-Canary-Version', 'canary');
  } else {
    req.canary = false;
    res.setHeader('X-Canary-Version', 'stable');
  }
  
  next();
};

app.use(canaryRouter);

最佳实践

错误处理

javascript

// 全局错误处理器
class AppError extends Error {
  constructor(message, statusCode, isOperational = true) {
    super(message);
    this.statusCode = statusCode;
    this.isOperational = isOperational;
    this.timestamp = new Date().toISOString();
    
    Error.captureStackTrace(this, this.constructor);
  }
}

// 异步错误包装器
const asyncHandler = (fn) => {
  return (req, res, next) => {
    Promise.resolve(fn(req, res, next)).catch(next);
  };
};

// 全局错误中间件
const errorHandler = (err, req, res, next) => {
  let error = { ...err };
  error.message = err.message;
  
  // 记录错误
  logger.error('Error occurred', {
    error: error.message,
    stack: error.stack,
    url: req.url,
    method: req.method,
    userId: req.user?.id,
    timestamp: error.timestamp
  });
  
  // 数据库错误
  if (err.code === '23505') {
    error = new AppError('Duplicate field value', 400);
  }
  
  // JWT 错误
  if (err.name === 'JsonWebTokenError') {
    error = new AppError('Invalid token', 401);
  }
  
  // 验证错误
  if (err.name === 'ValidationError') {
    const message = Object.values(err.errors).map(val => val.message).join(', ');
    error = new AppError(message, 400);
  }
  
  res.status(error.statusCode || 500).json({
    success: false,
    error: error.message || 'Server Error',
    ...(process.env.NODE_ENV === 'development' && { stack: error.stack })
  });
};

app.use(errorHandler);

配置管理

javascript

// 配置管理类
class ConfigManager {
  constructor() {
    this.config = this.loadConfig();
    this.validateConfig();
  }
  
  loadConfig() {
    return {
      app: {
        name: process.env.APP_NAME || 'Trae App',
        version: process.env.APP_VERSION || '1.0.0',
        port: parseInt(process.env.PORT) || 3000,
        env: process.env.NODE_ENV || 'development'
      },
      database: {
        host: process.env.DB_HOST || 'localhost',
        port: parseInt(process.env.DB_PORT) || 5432,
        name: process.env.DB_NAME || 'trae',
        user: process.env.DB_USER || 'postgres',
        password: process.env.DB_PASSWORD,
        ssl: process.env.DB_SSL === 'true',
        pool: {
          min: parseInt(process.env.DB_POOL_MIN) || 2,
          max: parseInt(process.env.DB_POOL_MAX) || 10
        }
      },
      redis: {
        host: process.env.REDIS_HOST || 'localhost',
        port: parseInt(process.env.REDIS_PORT) || 6379,
        password: process.env.REDIS_PASSWORD,
        db: parseInt(process.env.REDIS_DB) || 0
      },
      auth: {
        jwtSecret: process.env.JWT_SECRET,
        jwtExpiry: process.env.JWT_EXPIRY || '1h',
        refreshSecret: process.env.REFRESH_SECRET,
        refreshExpiry: process.env.REFRESH_EXPIRY || '7d'
      },
      monitoring: {
        enabled: process.env.MONITORING_ENABLED === 'true',
        metricsPort: parseInt(process.env.METRICS_PORT) || 9090,
        healthcheckPath: process.env.HEALTHCHECK_PATH || '/health'
      }
    };
  }
  
  validateConfig() {
    const required = [
      'DB_PASSWORD',
      'JWT_SECRET',
      'REFRESH_SECRET'
    ];
    
    const missing = required.filter(key => !process.env[key]);
    
    if (missing.length > 0) {
      throw new Error(`Missing required environment variables: ${missing.join(', ')}`);
    }
  }
  
  get(path) {
    return path.split('.').reduce((obj, key) => obj?.[key], this.config);
  }
  
  isDevelopment() {
    return this.config.app.env === 'development';
  }
  
  isProduction() {
    return this.config.app.env === 'production';
  }
}

const config = new ConfigManager();
module.exports = config;

健康检查

javascript

// 健康检查端点
app.get('/health', async (req, res) => {
  const health = {
    status: 'ok',
    timestamp: new Date().toISOString(),
    uptime: process.uptime(),
    version: config.get('app.version'),
    environment: config.get('app.env'),
    checks: {}
  };
  
  try {
    // 数据库健康检查
    await db.query('SELECT 1');
    health.checks.database = { status: 'ok' };
  } catch (error) {
    health.checks.database = { status: 'error', message: error.message };
    health.status = 'error';
  }
  
  try {
    // Redis 健康检查
    await client.ping();
    health.checks.redis = { status: 'ok' };
  } catch (error) {
    health.checks.redis = { status: 'error', message: error.message };
    health.status = 'error';
  }
  
  // 内存使用检查
  const memUsage = process.memoryUsage();
  const memUsageMB = Math.round(memUsage.heapUsed / 1024 / 1024);
  
  health.checks.memory = {
    status: memUsageMB < 500 ? 'ok' : 'warning',
    usage: `${memUsageMB}MB`,
    limit: '500MB'
  };
  
  const statusCode = health.status === 'ok' ? 200 : 503;
  res.status(statusCode).json(health);
});

// 就绪检查端点
app.get('/ready', async (req, res) => {
  try {
    // 检查关键依赖是否就绪
    await Promise.all([
      db.query('SELECT 1'),
      client.ping()
    ]);
    
    res.status(200).json({ status: 'ready' });
  } catch (error) {
    res.status(503).json({ 
      status: 'not ready', 
      error: error.message 
    });
  }
});

这个高级功能指南涵盖了 Trae 平台的核心高级功能，包括自定义工作流、调试工具、性能优化、安全配置、监控日志和部署策略。通过掌握这些功能，您可以构建更加健壮、高效和安全的应用程序。

高级功能指南 ​

概述 ​

自定义工作流 ​

工作流配置 ​

条件执行 ​

并行执行 ​

高级调试工具 ​

远程调试 ​

性能分析 ​

内存分析 ​

性能优化 ​

代码分割 ​

缓存策略 ​

数据库优化 ​

安全配置 ​

身份验证和授权 ​

安全头和 CORS ​

输入验证和清理 ​

监控和日志 ​

结构化日志 ​

应用监控 ​

部署策略 ​

蓝绿部署 ​

金丝雀部署 ​

最佳实践 ​

错误处理 ​

配置管理 ​

健康检查 ​

高级功能指南

概述

自定义工作流

工作流配置

条件执行

并行执行

高级调试工具

远程调试

性能分析

内存分析

性能优化

代码分割

缓存策略

数据库优化

安全配置

身份验证和授权

安全头和 CORS

输入验证和清理

监控和日志

结构化日志

应用监控

部署策略

蓝绿部署

金丝雀部署

最佳实践

错误处理

配置管理

健康检查