链路追踪与灰度发布

┌─────────┐
│  用户    │
└─────────┘
    ↓
┌─────────┐
│  网关    │
└─────────┘
    ↓
┌─────────┐
│ 订单服务 │
└─────────┘
    ↓
┌─────────┐
│ 库存服务 │
└─────────┘
    ↓
┌─────────┐
│ 支付服务 │
└─────────┘
    ↓
┌─────────┐
│ 消息队列 │
└─────────┘
    ↓
┌─────────┐
│异步消费者│
└─────────┘

链路追踪 = 问题定位 + 性能分析 + 依赖分析 + 故障还原

价值体现:
├─ 问题定位: 快速找到故障点
├─ 性能分析: 发现性能瓶颈
├─ 依赖分析: 理解服务依赖关系
└─ 故障还原: 还原故障现场

常见生成规则:

1. UUID
   - 优点: 简单,唯一性好
   - 缺点: 较长(36字符),无序

2. 雪花算法
   - 优点: 有序,较短
   - 缺点: 需要配置机器ID

3. 自定义规则
   - 示例: {时间戳}{机器ID}{序列号}
   - 优点: 可读性好,可解析
   - 缺点: 需要维护机器ID

// 生成 traceId
public class TraceIdGenerator {
    
    public static String generate() {
        // 方式1: UUID
        String traceId = UUID.randomUUID().toString().replace("-", "");
        
        // 方式2: 雪花算法
        // String traceId = String.valueOf(snowflakeIdWorker.nextId());
        
        return traceId;
    }
}

// 在网关生成 traceId
@Component
public class TraceIdFilter implements GlobalFilter, Ordered {
    
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        String traceId = exchange.getRequest().getHeaders().getFirst("X-Trace-Id");
        
        if (traceId == null || traceId.isEmpty()) {
            traceId = TraceIdGenerator.generate();
        }
        
        // 设置到 exchange attributes
        // 注意:网关基于 WebFlux,ThreadLocal 的 MDC 在响应式链路中不可靠,应使用 exchange attributes
        exchange.getAttributes().put("traceId", traceId);
        
        // 透传给下游服务
        ServerHttpRequest request = exchange.getRequest().mutate()
            .header("X-Trace-Id", traceId)
            .build();
        
        return chain.filter(exchange.mutate().request(request).build());
    }
    
    @Override
    public int getOrder() {
        return -1000;
    }
}

public class Span {
    
    private String traceId;          // 所属 trace
    private String spanId;           // 当前 span ID
    private String parentSpanId;     // 父 span ID
    private String operationName;    // 操作名称
    private long startTime;          // 开始时间
    private long endTime;            // 结束时间
    private long duration;           // 耗时(纳秒)
    private Map<String, String> tags; // 标签
    private List<LogEntry> logs;     // 日志
    private SpanStatus status;       // 状态
    
    public enum SpanStatus {
        OK,
        ERROR
    }
}

TraceId: 1234567890abcdef

Span 1: 网关 → 订单服务
├─ spanId: span-1
├─ parentSpanId: null (根 span)
├─ operationName: POST /api/orders
├─ startTime: 1640000000000000000
├─ endTime: 1640000000200000000
├─ duration: 200ms
├─ tags:
│   ├─ http.method: POST
│   ├─ http.url: /api/orders
│   └─ http.status_code: 200
└─ status: OK

Span 2: 订单服务 → 库存服务
├─ spanId: span-2
├─ parentSpanId: span-1
├─ operationName: POST /internal/inventory/decrement
├─ startTime: 1640000000050000000
├─ endTime: 1640000000150000000
├─ duration: 100ms
├─ tags:
│   ├─ http.method: POST
│   ├─ http.url: /internal/inventory/decrement
│   └─ http.status_code: 200
└─ status: OK

Span 3: 库存服务 → MySQL
├─ spanId: span-3
├─ parentSpanId: span-2
├─ operationName: UPDATE inventory
├─ startTime: 1640000000100000000
├─ endTime: 1640000000120000000
├─ duration: 20ms
├─ tags:
│   ├─ db.type: mysql
│   ├─ db.instance: inventory_db
│   └─ db.statement: UPDATE inventory SET count = count - ? WHERE id = ?
└─ status: OK

┌─────────────────────────────────────────────────────────┐
│                      应用服务                            │
│  ┌────────────────────────────────────────────────────┐ │
│  │                   Trace SDK                        │ │
│  │  ┌──────────┐  ┌──────────┐  ┌──────────┐        │ │
│  │  │ Trace    │  │ Span     │  │ Context  │        │ │
│  │  │ Builder  │  │ Manager  │  │ Propagator│       │ │
│  │  └──────────┘  └──────────┘  └──────────┘        │ │
│  └────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────┘
        ↓ 上报数据
┌─────────────────────────────────────────────────────────┐
│                    Trace Collector                       │
│  ┌────────────────────────────────────────────────────┐ │
│  │  - 接收 Trace 数据                                  │ │
│  │  - 数据验证和清洗                                    │ │
│  │  - 数据格式转换                                      │ │
│  └────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────┘
        ↓ 存储数据
┌─────────────────────────────────────────────────────────┐
│                    Trace Storage                         │
│  ┌────────────────────────────────────────────────────┐ │
│  │  - Elasticsearch (主流)                             │ │
│  │  - Cassandra                                        │ │
│  │  - MySQL (小规模)                                   │ │
│  └────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────┘
        ↓ 查询数据
┌─────────────────────────────────────────────────────────┐
│                    Trace UI                              │
│  ┌────────────────────────────────────────────────────┐ │
│  │  - 调用链路查询                                      │ │
│  │  - 性能分析                                          │ │
│  │  - 拓扑图                                            │ │
│  └────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────┘

// 手动埋点
Span span = tracer.spanBuilder("createOrder")
    .setParent(parentContext)
    .setSpanKind(SpanKind.CLIENT)
    .startSpan();

try {
    // 业务逻辑
    orderService.createOrder(request);
} catch (Exception e) {
    span.recordException(e);
    span.setStatus(StatusCode.ERROR);
    throw e;
} finally {
    span.end();
}

// 使用 AOP 自动埋点
@Aspect
@Component
public class TraceAspect {
    
    @Autowired
    private Tracer tracer;
    
    @Around("@annotation(org.springframework.web.bind.annotation.PostMapping)")
    public Object trace(ProceedingJoinPoint joinPoint) throws Throwable {
        Span span = tracer.spanBuilder(joinPoint.getSignature().getName())
            .setSpanKind(SpanKind.SERVER)
            .startSpan();
        
        try {
            return joinPoint.proceed();
        } catch (Exception e) {
            span.recordException(e);
            span.setStatus(StatusCode.ERROR);
            throw e;
        } finally {
            span.end();
        }
    }
}

# 使用 Java Agent 无侵入埋点
java -javaagent:/path/to/skywalking-agent.jar \
     -Dskywalking.agent.service_name=user-service \
     -Dskywalking.collector.backend_service=localhost:11800 \
     -jar user-service.jar

┌─────────────────────────────────────────────────────┐
│                完整链路追踪覆盖范围                    │
├─────────────────────────────────────────────────────┤
│  1. 同步调用                                         │
│     ├─ HTTP 调用                                    │
│     ├─ RPC 调用                                     │
│     └─ 数据库访问                                   │
├─────────────────────────────────────────────────────┤
│  2. 异步调用                                         │
│     ├─ MQ 消息投递                                  │
│     ├─ MQ 消息消费                                  │
│     └─ 线程池任务                                   │
├─────────────────────────────────────────────────────┤
│  3. 定时任务                                         │
│     ├─ 定时触发                                     │
│     └─ 任务执行                                     │
├─────────────────────────────────────────────────────┤
│  4. 缓存访问                                         │
│     ├─ Redis 调用                                   │
│     └─ 本地缓存                                     │
└─────────────────────────────────────────────────────┘

// 消息生产者
@Service
public class OrderService {
    
    @Autowired
    private RabbitTemplate rabbitTemplate;
    
    public void createOrder(Order order) {
        // 获取当前 trace context
        TraceContext context = TraceContextHolder.getCurrentContext();
        
        // 发送消息时透传 traceId
        rabbitTemplate.convertAndSend("order.queue", order, message -> {
            message.getMessageProperties().setHeader("X-Trace-Id", context.getTraceId());
            message.getMessageProperties().setHeader("X-Span-Id", context.getSpanId());
            return message;
        });
    }
}

// 消息消费者
@Component
public class OrderConsumer {
    
    @RabbitListener(queues = "order.queue")
    public void handleOrder(Message message) {
        // 从消息头提取 traceId
        String traceId = message.getMessageProperties().getHeader("X-Trace-Id");
        String parentSpanId = message.getMessageProperties().getHeader("X-Span-Id");
        
        // 设置新的 trace context
        TraceContext context = new TraceContext(traceId, parentSpanId);
        TraceContextHolder.setCurrentContext(context);
        
        try {
            // 处理消息
            processOrder(message);
        } finally {
            TraceContextHolder.clear();
        }
    }
}

// 使用线程池时透传 trace context
@Service
public class OrderService {
    
    @Autowired
    private ExecutorService executorService;
    
    public void processOrderAsync(Order order) {
        // 获取当前 trace context
        TraceContext context = TraceContextHolder.getCurrentContext();
        
        // 提交任务时透传
        executorService.submit(() -> {
            // 在新线程中设置 trace context
            TraceContextHolder.setCurrentContext(context);
            
            try {
                processOrder(order);
            } finally {
                TraceContextHolder.clear();
            }
        });
    }
}

// 使用装饰器模式自动透传
public class TraceContextExecutorService implements ExecutorService {
    
    private final ExecutorService delegate;
    
    public TraceContextExecutorService(ExecutorService delegate) {
        this.delegate = delegate;
    }
    
    @Override
    public void execute(Runnable command) {
        TraceContext context = TraceContextHolder.getCurrentContext();
        delegate.execute(() -> {
            TraceContextHolder.setCurrentContext(context);
            try {
                command.run();
            } finally {
                TraceContextHolder.clear();
            }
        });
    }
    
    // ... 其他方法类似
}

┌─────────────────────────────────────────────────────────┐
│                    SkyWalking Agent                      │
│  ┌────────────────────────────────────────────────────┐ │
│  │  - 数据采集                                          │ │
│  │  - 字节码增强                                        │ │
│  │  - Trace 数据生成                                    │ │
│  └────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────┘
        ↓ gRPC
┌─────────────────────────────────────────────────────────┐
│                    SkyWalking OAP                        │
│  ┌────────────────────────────────────────────────────┐ │
│  │  - 数据聚合                                          │ │
│  │  - 数据分析                                          │ │
│  │  - 告警判断                                          │ │
│  └────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────┘
        ↓ 存储
┌─────────────────────────────────────────────────────────┐
│                    Storage                               │
│  ┌────────────────────────────────────────────────────┐ │
│  │  - Elasticsearch (推荐)                             │ │
│  │  - H2 (测试)                                        │ │
│  │  - MySQL (小规模)                                   │ │
│  └────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────┘
        ↓ 查询
┌─────────────────────────────────────────────────────────┐
│                    SkyWalking UI                         │
│  ┌────────────────────────────────────────────────────┐ │
│  │  - 调用链路查询                                      │ │
│  │  - 拓扑图                                            │ │
│  │  - 性能指标                                          │ │
│  │  - 告警管理                                          │ │
│  └────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────┘

# 启动参数
java -javaagent:/path/to/skywalking-agent.jar \
     -Dskywalking.agent.service_name=user-service \
     -Dskywalking.collector.backend_service=localhost:11800 \
     -Dskywalking.agent.instance_properties_json='{"zone":"beijing"}' \
     -jar user-service.jar

# 服务名称
agent.service_name=${SW_AGENT_NAME:user-service}

# OAP 地址
collector.backend_service=${SW_AGENT_COLLECTOR_BACKEND_SERVICES:localhost:11800}

# 采样率(-1 表示全采样;正数表示每 3 秒采样条数)
agent.sample_n_per_3_secs=${SW_AGENT_SAMPLE:-1}

# 忽略的路径
agent.ignore_path=${SW_AGENT_IGNORE_PATH:/actuator/**,/health}

# 日志级别
logging.level=${SW_LOGGING_LEVEL:INFO}

import org.apache.skywalking.apm.toolkit.trace.TraceCrossThread;
import org.apache.skywalking.apm.toolkit.trace.Tracer;
import org.apache.skywalking.apm.toolkit.trace.TraceContext;

@Service
public class OrderService {
    
    // 手动创建 Span
    public void createOrder(Order order) {
        // 创建活跃 Span
        AbstractSpan span = Tracer.createEntrySpan("createOrder");
        
        try {
            // 添加标签
            span.tag("orderId", order.getId());
            span.tag("userId", order.getUserId());
            
            // 业务逻辑
            orderRepository.save(order);
            
        } catch (Exception e) {
            // 记录异常
            span.errorOccurred().log(e);
            throw e;
        } finally {
            // 结束 Span
            Tracer.stopSpan();
        }
    }
    
    // 异步调用
    @Async
    @TraceCrossThread
    public void asyncProcess(Order order) {
        // 自动继承父线程的 trace context
        processOrder(order);
    }
    
    // 获取 TraceId
    public String getTraceId() {
        return TraceContext.traceId();
    }
}

import org.apache.skywalking.apm.toolkit.trace.annotation.Trace;

@Service
public class OrderService {
    
    @Trace(operationName = "createOrder")
    @Tag(key = "orderId", value = "arg[0].id")
    @Tag(key = "userId", value = "arg[0].userId")
    public void createOrder(Order order) {
        orderRepository.save(order);
    }
}

┌─────────────────────────────────────────────────────────┐
│                  Application                             │
│  ┌────────────────────────────────────────────────────┐ │
│  │                   Brave SDK                        │ │
│  └────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────┘
        ↓ HTTP/Kafka
┌─────────────────────────────────────────────────────────┐
│                    Zipkin Server                         │
│  ┌────────────────────────────────────────────────────┐ │
│  │  - 数据收集                                          │ │
│  │  - 数据存储                                          │ │
│  │  - 数据查询                                          │ │
│  │  - UI 展示                                           │ │
│  └────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────┘
        ↓ 存储
┌─────────────────────────────────────────────────────────┐
│                    Storage                               │
│  ┌────────────────────────────────────────────────────┐ │
│  │  - Elasticsearch                                    │ │
│  │  - Cassandra                                        │ │
│  │  - MySQL                                            │ │
│  └────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────┘

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-sleuth</artifactId>
</dependency>

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-sleuth-zipkin</artifactId>
</dependency>

spring:
  zipkin:
    base-url: http://localhost:9411
    sender:
      type: web
  sleuth:
    sampler:
      probability: 1.0  # 采样率 100%
    web:
      skip-pattern: /actuator.*,/health

import brave.Span;
import brave.Tracer;

@Service
public class OrderService {
    
    @Autowired
    private Tracer tracer;
    
    public void createOrder(Order order) {
        Span span = tracer.nextSpan().name("createOrder").start();
        
        try (Tracer.SpanInScope ws = tracer.withSpanInScope(span)) {
            span.tag("orderId", order.getId());
            span.tag("userId", order.getUserId());
            
            orderRepository.save(order);
            
        } catch (Exception e) {
            span.error(e);
            throw e;
        } finally {
            span.finish();
        }
    }
}

┌─────────────────────────────────────────────────────────┐
│                  Application                             │
│  ┌────────────────────────────────────────────────────┐ │
│  │                  Jaeger Client                     │ │
│  └────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────┘
        ↓ UDP/HTTP
┌─────────────────────────────────────────────────────────┐
│                    Jaeger Agent                          │
│  ┌────────────────────────────────────────────────────┐ │
│  │  - 数据收集                                          │ │
│  │  - 数据转发                                          │ │
│  └────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────┘
        ↓ gRPC
┌─────────────────────────────────────────────────────────┐
│                    Jaeger Collector                      │
│  ┌────────────────────────────────────────────────────┐ │
│  │  - 数据验证                                          │ │
│  │  - 数据转换                                          │ │
│  │  - 数据存储                                          │ │
│  └────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────┘
        ↓ 存储
┌─────────────────────────────────────────────────────────┐
│                    Storage                               │
│  ┌────────────────────────────────────────────────────┐ │
│  │  - Elasticsearch                                    │ │
│  │  - Cassandra                                        │ │
│  │  - Kafka                                            │ │
│  └────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────┘

<dependency>
    <groupId>io.jaegertracing</groupId>
    <artifactId>jaeger-client</artifactId>
    <version>1.8.1</version>
</dependency>

@Configuration
public class JaegerConfig {
    
    @Bean
    public io.jaegertracing.Tracer jaegerTracer() {
        return new Configuration("user-service")
            .withSampler(new Configuration.SamplerConfiguration()
                .withType(ConstSampler.TYPE)
                .withParam(1))
            .withReporter(new Configuration.ReporterConfiguration()
                .withLogSpans(true)
                .withFlushInterval(1000)
                .withMaxQueueSize(10000)
                .withSender(new Configuration.SenderConfiguration()
                    .withEndpoint("http://localhost:14268/api/traces")))
            .getTracer();
    }
}

推荐: SkyWalking
理由:
- 无侵入,Java Agent 方式
- 国产,中文文档完善
- 功能全面(APM + Trace)
- 性能好

推荐: Zipkin + Spring Cloud Sleuth
理由:
- 与 Spring Cloud 深度集成
- 配置简单
- 社区成熟

推荐: Jaeger
理由:
- 云原生设计
- 支持 Istio
- 高性能

推荐: Jaeger 或 SkyWalking
理由:
- 都支持多语言
- OpenTracing 兼容

传统发布(全量发布):
┌─────────────────────────────────────────────────────┐
│  V1 (100%)                                          │
│  ┌──────────────────────────────────────────────┐  │
│  │  用户1, 用户2, 用户3, ..., 用户N               │  │
│  │  如果出问题,所有用户都受影响                   │  │
│  └──────────────────────────────────────────────┘  │
└─────────────────────────────────────────────────────┘
        ↓ 一键切换
┌─────────────────────────────────────────────────────┐
│  V2 (100%)                                          │
│  ┌──────────────────────────────────────────────┐  │
│  │  用户1, 用户2, 用户3, ..., 用户N               │  │
│  │  新版本对所有用户生效                          │  │
│  └──────────────────────────────────────────────┘  │
└─────────────────────────────────────────────────────┘

风险: 全量切换,如果新版本有问题,影响所有用户


灰度发布(逐步放量):
┌─────────────────────────────────────────────────────┐
│  V1 (95%)                      V2 (5%)              │
│  ┌──────────────────────────┐  ┌──────────┐        │
│  │ 用户1, ..., 用户N-1       │  │ 用户N     │        │
│  │ 95% 用户使用旧版本         │  │ 5% 灰度   │        │
│  └──────────────────────────┘  └──────────┘        │
└─────────────────────────────────────────────────────┘
        ↓ 观察,无异常
┌─────────────────────────────────────────────────────┐
│  V1 (80%)                     V2 (20%)              │
│  ┌────────────────────────┐  ┌────────────────┐    │
│  │ 用户1, ..., 用户N-4     │  │ 用户N-3...用户N │    │
│  │ 80% 用户使用旧版本      │  │ 20% 灰度        │    │
│  └────────────────────────┘  └────────────────┘    │
└─────────────────────────────────────────────────────┘
        ↓ 观察,无异常
┌─────────────────────────────────────────────────────┐
│  V1 (0%)                      V2 (100%)             │
│  ┌──────────────────────────┐  ┌──────────────────┐ │
│  │ (空)                      │  │ 所有用户         │ │
│  │                           │  │ 新版本全量       │ │
│  └──────────────────────────┘  └──────────────────┘ │
└─────────────────────────────────────────────────────┘

优势: 逐步放量,如有问题可快速回滚,影响范围可控

# Istio VirtualService
apiVersion: networking.istio.io/v1alpha3
kind: VirtualService
metadata:
  name: user-service
spec:
  hosts:
  - user-service
  http:
  - route:
    - destination:
        host: user-service
        subset: v1
      weight: 90  # 90% 流量到 v1
    - destination:
        host: user-service
        subset: v2
      weight: 10  # 10% 流量到 v2

# Istio VirtualService
apiVersion: networking.istio.io/v1alpha3
kind: VirtualService
metadata:
  name: user-service
spec:
  hosts:
  - user-service
  http:
  - match:
    - headers:
        X-User-Id:
          exact: "12345"  # 指定用户 ID
    route:
    - destination:
        host: user-service
        subset: v2
  - route:
    - destination:
        host: user-service
        subset: v1

// 基于租户 ID 的灰度路由(示意)
@Component
public class TenantGrayLoadBalancer implements ReactorServiceInstanceLoadBalancer {

    private final ServiceInstanceListSupplier supplier;

    public TenantGrayLoadBalancer(ServiceInstanceListSupplier supplier, String serviceId) {
        this.supplier = supplier;
    }

    @Override
    public Mono<Response<ServiceInstance>> choose(Request request) {
        ServerWebExchange exchange = (ServerWebExchange) request.getContext();
        String tenantId = exchange.getRequest().getHeaders().getFirst("X-Tenant-Id");

        // 根据租户 ID 选择实例
        return supplier.get().next()
            .map(instances -> new DefaultResponse(selectInstanceByTenant(instances, tenantId)));
    }

    private ServiceInstance selectInstanceByTenant(List<ServiceInstance> instances, String tenantId) {
        // 按 metadata 中的租户/版本标记筛选,未命中则退回普通实例
        return instances.stream()
            .filter(i -> tenantId != null && tenantId.equals(i.getMetadata().get("tenant")))
            .findFirst()
            .orElse(instances.get(0));
    }
}

# Nginx 灰度配置
upstream user-service {
    # 北京机房
    server user-service-beijing:8080 weight=90;
    
    # 上海机房
    server user-service-shanghai:8080 weight=10;
}

# 根据请求来源 IP 路由
map $remote_addr $backend {
    default user-service;
    ~^10\.0\.1\. user-service-beijing;
    ~^10\.0\.2\. user-service-shanghai;
}

// 基于 Header 的灰度路由(示意)
@Component
public class HeaderGrayLoadBalancer implements ReactorServiceInstanceLoadBalancer {

    private final ServiceInstanceListSupplier supplier;

    public HeaderGrayLoadBalancer(ServiceInstanceListSupplier supplier, String serviceId) {
        this.supplier = supplier;
    }

    @Override
    public Mono<Response<ServiceInstance>> choose(Request request) {
        ServerWebExchange exchange = (ServerWebExchange) request.getContext();
        String grayVersion = exchange.getRequest().getHeaders().getFirst("X-Gray-Version");

        String target = "v2".equals(grayVersion) ? "v2" : "v1";
        // 根据灰度版本选择实例
        return supplier.get().next()
            .map(instances -> new DefaultResponse(selectByVersion(instances, target)));
    }

    private ServiceInstance selectByVersion(List<ServiceInstance> instances, String version) {
        // 按 metadata 中的 version 标记筛选,未命中则退回第一个实例
        return instances.stream()
            .filter(i -> version.equals(i.getMetadata().get("version")))
            .findFirst()
            .orElse(instances.get(0));
    }
}

灰度监控指标体系:
├─ 技术指标
│   ├─ 错误率: 灰度版本 vs 基线版本
│   ├─ RT: P50、P95、P99
│   ├─ QPS: 灰度流量占比
│   └─ 资源使用: CPU、内存、线程池
├─ 业务指标
│   ├─ 核心业务成功率: 下单、支付
│   ├─ 转化率: 访问 → 下单 → 支付
│   └─ 业务错误率: 业务异常占比
└─ 对比指标
    ├─ 灰度版本 vs 基线版本
    ├─ 灰度前 vs 灰度后
    └─ 历史同期对比

// 灰度路由过滤器
@Component
public class GrayRouteFilter implements GlobalFilter, Ordered {
    
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        // 从请求头获取灰度标识
        String grayVersion = exchange.getRequest().getHeaders().getFirst("X-Gray-Version");
        String grayUser = exchange.getRequest().getHeaders().getFirst("X-Gray-User");
        
        // 灰度规则判断
        if (isGrayUser(grayUser) || isGrayVersion(grayVersion)) {
            // 添加灰度标识
            ServerHttpRequest request = exchange.getRequest().mutate()
                .header("X-Service-Version", "v2")
                .build();
            
            return chain.filter(exchange.mutate().request(request).build());
        }
        
        return chain.filter(exchange);
    }
    
    @Override
    public int getOrder() {
        return -50;
    }
}

# application.yml
spring:
  cloud:
    gateway:
      routes:
        - id: user-service-v1
          uri: lb://user-service-v1
          predicates:
            - Path=/api/users/**
            - Header=X-Service-Version, v1
          
        - id: user-service-v2
          uri: lb://user-service-v2
          predicates:
            - Path=/api/users/**
            - Header=X-Service-Version, v2

# 灰度实例配置
spring:
  application:
    name: user-service
  cloud:
    nacos:
      discovery:
        server-addr: localhost:8848
        metadata:
          version: v2  # 版本标记
          gray: true   # 灰度标记

// 灰度负载均衡器(示意)
@Component
public class GrayLoadBalancer implements ReactorServiceInstanceLoadBalancer {
    
    @Autowired
    private GrayRuleConfig grayRuleConfig;
    
    private final ServiceInstanceListSupplier supplier;
    
    public GrayLoadBalancer(ServiceInstanceListSupplier supplier, String serviceId) {
        this.supplier = supplier;
    }
    
    @Override
    public Mono<Response<ServiceInstance>> choose(Request request) {
        // 获取灰度标识
        String grayVersion = getGrayVersion(request);
        
        // 根据灰度规则选择实例
        return supplier.get().next()
            .map(instances -> new DefaultResponse(selectInstance(instances, grayVersion)));
    }
    
    private String getGrayVersion(Request request) {
        // 从 Header 获取(Spring Cloud LoadBalancer 网关场景下 context 即 ServerWebExchange)
        ServerWebExchange exchange = (ServerWebExchange) request.getContext();
        String version = exchange.getRequest()
            .getHeaders()
            .getFirst("X-Gray-Version");
        
        if (version != null) {
            return version;
        }
        
        // 从配置获取默认灰度规则
        return grayRuleConfig.getDefaultVersion();
    }
    
    private ServiceInstance selectInstance(List<ServiceInstance> instances, String grayVersion) {
        // 过滤出指定版本的实例
        List<ServiceInstance> filtered = instances.stream()
            .filter(instance -> grayVersion.equals(instance.getMetadata().get("version")))
            .collect(Collectors.toList());
        
        if (filtered.isEmpty()) {
            // 没有灰度实例,使用基线版本
            filtered = instances.stream()
                .filter(instance -> "v1".equals(instance.getMetadata().get("version")))
                .collect(Collectors.toList());
        }
        
        // 简化处理:未做二次负载均衡,取第一个实例(生产中应在此处再做随机/轮询)
        return filtered.get(0);
    }
}

# DestinationRule - 定义版本子集
apiVersion: networking.istio.io/v1alpha3
kind: DestinationRule
metadata:
  name: user-service
spec:
  host: user-service
  subsets:
  - name: v1
    labels:
      version: v1
  - name: v2
    labels:
      version: v2

---
# VirtualService - 灰度路由规则
apiVersion: networking.istio.io/v1alpha3
kind: VirtualService
metadata:
  name: user-service
spec:
  hosts:
  - user-service
  http:
  # 基于 Header 的灰度
  - match:
    - headers:
        X-Gray-Version:
          exact: "v2"
    route:
    - destination:
        host: user-service
        subset: v2
  
  # 基于权重的灰度
  - route:
    - destination:
        host: user-service
        subset: v1
      weight: 90
    - destination:
        host: user-service
        subset: v2
      weight: 10
    
    # 重试配置
    retries:
      attempts: 3
      perTryTimeout: 2s
    
    # 超时配置
    timeout: 10s
    
    # 故障注入配置(用于灰度演练验证,非熔断;熔断由 DestinationRule 的 outlierDetection 配置)
    fault:
      abort:
        percentage:
          value: 0.1
        httpStatus: 503

// 特性开关配置
@Configuration
@RefreshScope
public class FeatureToggleConfig {
    
    @Value("${feature.new-order-flow.enabled:false}")
    private boolean newOrderFlowEnabled;
    
    @Value("${feature.new-order-flow.percentage:0}")
    private int newOrderFlowPercentage;
    
    @Value("${feature.new-order-flow.whitelist:}")
    private String newOrderFlowWhitelist;
    
    public boolean isNewOrderFlowEnabled(Long userId) {
        if (!newOrderFlowEnabled) {
            return false;
        }
        
        // 白名单用户
        if (newOrderFlowWhitelist.contains(userId.toString())) {
            return true;
        }
        
        // 按比例灰度
        return userId % 100 < newOrderFlowPercentage;
    }
}

// 使用特性开关
@Service
public class OrderService {
    
    @Autowired
    private FeatureToggleConfig featureToggleConfig;
    
    public Order createOrder(OrderRequest request) {
        if (featureToggleConfig.isNewOrderFlowEnabled(request.getUserId())) {
            // 新流程
            return createOrderNew(request);
        } else {
            // 旧流程
            return createOrderOld(request);
        }
    }
}

# Nacos 配置
feature:
  new-order-flow:
    enabled: true
    percentage: 10  # 10% 用户使用新流程
    whitelist: 12345,67890  # 白名单用户

# v1 版本实例
spring:
  application:
    name: order-service
  cloud:
    nacos:
      discovery:
        metadata:
          version: v1

# v2 版本实例
spring:
  application:
    name: order-service
  cloud:
    nacos:
      discovery:
        metadata:
          version: v2

@Component
public class OrderGrayLoadBalancer implements ReactorServiceInstanceLoadBalancer {

    private final ServiceInstanceListSupplier supplier;

    public OrderGrayLoadBalancer(ServiceInstanceListSupplier supplier, String serviceId) {
        this.supplier = supplier;
    }

    @Override
    public Mono<Response<ServiceInstance>> choose(Request request) {
        ServerWebExchange exchange = (ServerWebExchange) request.getContext();
        String grayVersion = exchange.getRequest().getHeaders().getFirst("X-Gray-Version");

        // 根据灰度版本选择实例
        return supplier.get().next()
            .map(instances -> new DefaultResponse(selectByVersion(instances, grayVersion)));
    }

    private ServiceInstance selectByVersion(List<ServiceInstance> instances, String grayVersion) {
        // 按 metadata 中的 version 标记筛选,未命中则退回第一个实例
        return instances.stream()
            .filter(i -> grayVersion != null && grayVersion.equals(i.getMetadata().get("version")))
            .findFirst()
            .orElse(instances.get(0));
    }
}

灰度流程:
1. 部署 v2 版本
    ↓
2. 5% 流量灰度(内部测试)
    - 监控错误率、RT
    - 观察业务指标
    ↓
3. 10% 流量灰度
    - 继续监控
    - 对比 v1 vs v2
    ↓
4. 30% 流量灰度
    - 扩大灰度范围
    - 关注告警
    ↓
5. 50% 流量灰度
    - 半量验证
    ↓
6. 100% 流量灰度
    - 全量切换
    ↓
7. 下线 v1 版本

灰度期间重点监控:
├─ 技术指标
│   ├─ 错误率: v2 < v1 * 1.1
│   ├─ RT: v2 < v1 * 1.2
│   └─ 资源使用: CPU < 70%, Memory < 80%
├─ 业务指标
│   ├─ 下单成功率: v2 ≥ v1
│   ├─ 支付成功率: v2 ≥ v1
│   └─ 订单量: v2 ≈ v1
└─ 告警规则
    ├─ 错误率 > 1% → 告警
    ├─ RT P95 > 500ms → 告警
    └─ 业务成功率下降 > 5% → 告警

在 SkyWalking UI 查询:
- TraceId: 从用户请求获取
- 或根据时间范围查询慢 Trace

查看链路详情:
┌─────────────────────────────────────────────────────┐
│ TraceId: 1234567890abcdef                           │
│ Total Duration: 850ms                               │
├─────────────────────────────────────────────────────┤
│ 网关 → 订单服务                                      │
│   Duration: 850ms                                   │
│   ├─ 订单服务 → 库存服务                             │
│   │   Duration: 200ms                               │
│   │   └─ 库存服务 → MySQL                            │
│   │       Duration: 150ms ← 慢!                     │
│   ├─ 订单服务 → 支付服务                             │
│   │   Duration: 300ms ← 慢!                         │
│   │   └─ 支付服务 → 第三方支付                       │
│   │       Duration: 280ms                           │
│   └─ 订单服务 → Redis                                │
│       Duration: 10ms                                │
└─────────────────────────────────────────────────────┘

性能瓶颈分析:
1. 支付服务调用第三方支付: 280ms (可优化空间小)
2. 库存服务数据库查询: 150ms (可能存在慢 SQL)
3. 订单服务内部处理: 100ms (可接受)

优化建议:
1. 检查库存服务 SQL:
   - 是否缺少索引
   - 是否存在全表扫描
   - 是否锁等待

2. 支付服务优化:
   - 异步化非核心流程
   - 使用缓存

# 从 SkyWalking 查看 SQL 详情
Operation: SELECT * FROM inventory WHERE product_id = ?
Duration: 150ms
TraceId: 1234567890abcdef

# 分析 SQL 执行计划
EXPLAIN SELECT * FROM inventory WHERE product_id = ?;

// 特性开关管理
@Service
public class FeatureToggleService {
    
    @Autowired
    private RedisTemplate<String, String> redisTemplate;
    
    public boolean isFeatureEnabled(String featureName, Long userId) {
        // 1. 检查全局开关
        if (!isGlobalEnabled(featureName)) {
            return false;
        }
        
        // 2. 检查白名单
        if (isInWhitelist(featureName, userId)) {
            return true;
        }
        
        // 3. 检查灰度比例
        return isInGrayPercentage(featureName, userId);
    }
    
    private boolean isGlobalEnabled(String featureName) {
        String key = "feature:" + featureName + ":enabled";
        return Boolean.TRUE.equals(redisTemplate.opsForValue().get(key));
    }
    
    private boolean isInWhitelist(String featureName, Long userId) {
        String key = "feature:" + featureName + ":whitelist";
        return Boolean.TRUE.equals(redisTemplate.opsForSet().isMember(key, userId.toString()));
    }
    
    private boolean isInGrayPercentage(String featureName, Long userId) {
        String key = "feature:" + featureName + ":percentage";
        String percentage = redisTemplate.opsForValue().get(key);
        
        if (percentage == null) {
            return false;
        }
        
        int grayPercentage = Integer.parseInt(percentage);
        return userId % 100 < grayPercentage;
    }
}

// 使用特性开关
@RestController
public class OrderController {
    
    @Autowired
    private FeatureToggleService featureToggleService;
    
    @PostMapping("/orders")
    public Order createOrder(@RequestBody OrderRequest request) {
        // 根据特性开关选择不同逻辑
        if (featureToggleService.isFeatureEnabled("new-order-flow", request.getUserId())) {
            return orderService.createOrderNew(request);
        } else {
            return orderService.createOrderOld(request);
        }
    }
}

采样率建议:
- 开发环境: 100%
- 测试环境: 100%
- 预发环境: 50%
- 生产环境: 1-10%

注意:
- 关键链路: 100% 采样
- 非关键链路: 采样率可低
- 错误请求: 必须 100% 采样

TraceId 透传规范:
├─ HTTP 调用
│   ├─ Request Header: X-Trace-Id
│   └─ Response Header: X-Trace-Id (可选)
├─ RPC 调用
│   └─ RPC Context: TraceId
├─ MQ 消息
│   └─ Message Header: X-Trace-Id
├─ 异步线程
│   └─ ThreadLocal: TraceContext
└─ 日志输出
    └─ MDC: traceId

性能优化建议:
1. 异步上报数据
2. 批量发送 Span
3. 合理设置采样率
4. 使用高效的序列化方式
5. Agent 使用独立的线程池

标准灰度流程:
1. 代码评审 + 测试环境验证
    ↓
2. 预发环境验证
    ↓
3. 生产环境灰度
    ├─ 5% (内部测试)
    ├─ 10% (小范围验证)
    ├─ 30% (扩大范围)
    ├─ 50% (半量验证)
    └─ 100% (全量切换)
    ↓
4. 观察期(24-72小时)
    ↓
5. 下线旧版本

回滚预案:
1. 快速回滚
   - 调整流量权重
   - 关闭特性开关
   - 下线灰度实例

2. 代码回滚
   - 保留旧版本代码
   - 准备回滚脚本
   - 测试回滚流程

3. 数据回滚
   - 数据库变更可逆
   - 数据迁移脚本
   - 数据校验脚本

灰度监控体系:
├─ 实时监控
│   ├─ 错误率监控
│   ├─ RT 监控
│   └─ 业务指标监控
├─ 对比分析
│   ├─ v1 vs v2
│   └─ 灰度前后对比
├─ 告警规则
│   ├─ 错误率 > 阈值
│   ├─ RT > 阈值
│   └─ 业务成功率下降
└─ 值班机制
    ├─ 灰度期间值班
    └─ 快速响应

1. 检查 traceId 是否在网关或入口处生成
   - 查看网关日志
   - 检查 TraceIdFilter

2. 检查 HTTP、RPC、MQ 调用是否透传上下文
   - 查看请求头
   - 检查消息头

3. 检查异步线程或线程池切换时是否丢失 trace
   - 使用装饰器模式
   - 手动透传 TraceContext

4. 检查日志、指标和 trace 是否能互相关联
   - 日志中是否包含 traceId
   - 指标是否包含 trace 维度

1. 检查采样率
   - 采样率过高
   - 建议: 生产环境 1-10%

2. 检查上报方式
   - 同步上报 → 改为异步
   - 单条上报 → 改为批量

3. 检查序列化方式
   - JSON 序列化较慢
   - 考虑二进制序列化

4. 检查 Agent 配置
   - 缓冲区大小
   - 上报间隔

1. 检查灰度规则配置
   - 权重配置是否正确
   - 白名单配置是否正确

2. 检查灰度标识透传
   - Header 是否正确透传
   - Cookie 是否正确解析

3. 检查负载均衡策略
   - 是否支持灰度路由
   - 是否有缓存导致规则不生效

4. 检查回滚流程
   - 回滚脚本是否准备好
   - 回滚是否测试过

1. 检查实例元数据
   - 版本标记是否正确
   - 是否已注册到注册中心

2. 检查路由规则
   - 路由条件是否正确
   - 优先级是否合理

3. 检查请求特征
   - Header 是否包含灰度标识
   - 用户 ID 是否在白名单中

4. 检查日志
   - 灰度路由日志
   - 负载均衡日志

技术指标:
- CPU、内存使用率正常
- 错误率正常
- RT 正常

业务指标:
- 下单成功率下降
- 支付成功率下降
- 转化率下降

结论:
技术指标正常 ≠ 业务正常
业务指标正常 = 发布成功

1. 快速回滚
   - 调整流量权重
   - 关闭特性开关
   - 下线灰度实例

2. 代码回滚
   - 保留旧版本代码
   - 准备回滚脚本
   - 测试回滚流程

3. 数据回滚
   - 数据库变更可逆
   - 数据迁移脚本
   - 数据校验脚本

4. 回滚测试
   - 测试环境验证
   - 预发环境验证
   - 回滚演练