// 日志收集架构
public class LogCollection {
    
    // 1. 应用日志输出
    @RestController
    public class LogController {
        
        private static final Logger logger = LoggerFactory.getLogger(LogController.class);
        
        @GetMapping("/api/test")
        public String test() {
            // 结构化日志
            logger.info("请求处理开始", 
                kv("requestId", UUID.randomUUID().toString()),
                kv("path", "/api/test"),
                kv("method", "GET")
            );
            
            try {
                // 业务逻辑
                return "success";
            } catch (Exception e) {
                // 错误日志
                logger.error("请求处理失败", 
                    kv("requestId", UUID.randomUUID().toString()),
                    kv("error", e.getMessage()),
                    kv("stackTrace", ExceptionUtils.getStackTrace(e))
                );
                throw e;
            } finally {
                logger.info("请求处理完成", 
                    kv("requestId", UUID.randomUUID().toString()),
                    kv("duration", System.currentTimeMillis())
                );
            }
        }
    }
    
    // 2. 日志配置（Logback）
    // logback-spring.xml
    /*
    <configuration>
        <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
            <encoder>
                <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
            </encoder>
        </appender>
        
        <appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
            <file>logs/application.log</file>
            <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
                <fileNamePattern>logs/application.%d{yyyy-MM-dd}.log</fileNamePattern>
                <maxHistory>30</maxHistory>
            </rollingPolicy>
            <encoder>
                <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
            </encoder>
        </appender>
        
        <appender name="JSON" class="ch.qos.logback.core.rolling.RollingFileAppender">
            <file>logs/application.json</file>
            <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
                <fileNamePattern>logs/application.%d{yyyy-MM-dd}.json</fileNamePattern>
            </rollingPolicy>
            <encoder class="net.logstash.logback.encoder.LogstashEncoder">
                <includeContext>true</includeContext>
                <includeCallerData>true</includeCallerData>
            </encoder>
        </appender>
        
        <root level="INFO">
            <appender-ref ref="CONSOLE" />
            <appender-ref ref="FILE" />
            <appender-ref ref="JSON" />
        </root>
    </configuration>
    */
}

// Filebeat配置
// filebeat.yml
/*
filebeat.inputs:
  - type: log
    enabled: true
    paths:
      - /var/log/application/*.log
    fields:
      service: user-service
      environment: production
    fields_under_root: true
    multiline.pattern: '^\d{4}-\d{2}-\d{2}'
    multiline.negate: true
    multiline.match: after

output.logstash:
  hosts: ["logstash:5044"]

processors:
  - add_host_metadata:
      when.not.contains.tags: forwarded
  - add_docker_metadata: ~
*/

// 日志分析工具
public class LogAnalysis {
    
    // 1. 日志查询（Kibana DSL）
    /*
    GET /logs-*/_search
    {
      "query": {
        "bool": {
          "must": [
            { "match": { "level": "ERROR" } },
            { "range": { "@timestamp": { "gte": "now-1h" } } }
          ]
        }
      },
      "aggs": {
        "errors_by_service": {
          "terms": { "field": "service.keyword" },
          "aggs": {
            "error_count": { "value_count": { "field": "_id" } }
          }
        }
      }
    }
    */
    
    // 2. 日志分析服务
    @Service
    public class LogAnalysisService {
        
        @Autowired
        private ElasticsearchClient elasticsearchClient;
        
        // 错误日志统计
        public Map<String, Long> getErrorLogStats(String timeRange) {
            SearchRequest searchRequest = SearchRequest.of(s -> s
                .index("logs-*")
                .query(q -> q
                    .bool(b -> b
                        .must(m -> m.match(t -> t.field("level").query("ERROR")))
                        .must(m -> m.range(r -> r
                            .field("@timestamp")
                            .gte(JsonData.of("now-" + timeRange))
                        ))
                    )
                )
                .aggregations("errors_by_service", a -> a
                    .terms(t -> t.field("service.keyword"))
                    .aggregations("error_count", a2 -> a2
                        .valueCount(v -> v.field("_id"))
                    )
                )
            );
            
            SearchResponse<Object> response = elasticsearchClient.search(searchRequest, Object.class);
            // 处理结果
            return processResponse(response);
        }
        
        // 日志搜索
        public List<LogEntry> searchLogs(LogSearchRequest request) {
            SearchRequest searchRequest = SearchRequest.of(s -> s
                .index("logs-*")
                .query(q -> buildQuery(request))
                .sort(so -> so.field(f -> f.field("@timestamp").order(SortOrder.Desc)))
                .from(request.getFrom())
                .size(request.getSize())
            );
            
            SearchResponse<LogEntry> response = elasticsearchClient.search(searchRequest, LogEntry.class);
            return response.hits().hits().stream()
                .map(hit -> hit.source())
                .collect(Collectors.toList());
        }
    }
}

// Prometheus指标采集
public class MetricsCollection {
    
    // 1. Prometheus客户端
    @Component
    public class PrometheusMetrics {
        
        // Counter（计数器）
        private final Counter requestCounter = Counter.build()
            .name("http_requests_total")
            .help("Total HTTP requests")
            .labelNames("method", "path", "status")
            .register();
        
        // Gauge（仪表盘）
        private final Gauge activeConnections = Gauge.build()
            .name("active_connections")
            .help("Active connections")
            .register();
        
        // Histogram（直方图）
        private final Histogram requestDuration = Histogram.build()
            .name("http_request_duration_seconds")
            .help("HTTP request duration")
            .labelNames("method", "path")
            .buckets(0.1, 0.5, 1.0, 2.0, 5.0)
            .register();
        
        // Summary（摘要）
        private final Summary responseSize = Summary.build()
            .name("http_response_size_bytes")
            .help("HTTP response size")
            .labelNames("method", "path")
            .quantile(0.5, 0.05)
            .quantile(0.95, 0.01)
            .quantile(0.99, 0.001)
            .register();
        
        // 记录指标
        public void recordRequest(String method, String path, int status, double duration) {
            requestCounter.labels(method, path, String.valueOf(status)).inc();
            requestDuration.labels(method, path).observe(duration);
        }
    }
    
    // 2. Spring Boot Actuator集成
    @Configuration
    public class ActuatorConfig {
        
        @Bean
        public MeterRegistryCustomizer<MeterRegistry> metricsCommonTags() {
            return registry -> registry.config().commonTags(
                "application", "user-service",
                "environment", "production"
            );
        }
    }
    
    // 3. 自定义指标
    @Component
    public class CustomMetrics {
        
        private final MeterRegistry meterRegistry;
        
        public CustomMetrics(MeterRegistry meterRegistry) {
            this.meterRegistry = meterRegistry;
        }
        
        // 业务指标
        public void recordBusinessMetric(String businessType, double value) {
            meterRegistry.counter("business_metric_total", 
                "type", businessType).increment(value);
        }
        
        // JVM指标
        public void recordJvmMetrics() {
            MemoryMXBean memoryBean = ManagementFactory.getMemoryMXBean();
            MemoryUsage heapUsage = memoryBean.getHeapMemoryUsage();
            
            meterRegistry.gauge("jvm_memory_used_bytes", 
                Tags.of("area", "heap"), 
                heapUsage.getUsed());
            
            meterRegistry.gauge("jvm_memory_max_bytes", 
                Tags.of("area", "heap"), 
                heapUsage.getMax());
        }
    }
}

// 链路追踪实现
public class DistributedTracing {
    
    // 1. Spring Cloud Sleuth集成
    @SpringBootApplication
    public class TracingApplication {
        
        public static void main(String[] args) {
            SpringApplication.run(TracingApplication.class, args);
        }
        
        // Sleuth配置
        @Bean
        public Sampler alwaysSampler() {
            return Sampler.alwaysSample();
        }
    }
    
    // 2. 手动创建Span
    @Service
    public class TracingService {
        
        @Autowired
        private Tracer tracer;
        
        public String processRequest(String requestId) {
            // 创建Span
            Span span = tracer.nextSpan()
                .name("process-request")
                .tag("requestId", requestId)
                .start();
            
            try (Tracer.SpanInScope ws = tracer.withSpanInScope(span)) {
                // 业务逻辑
                String result = doProcess(requestId);
                
                // 添加事件
                span.event("request-processed");
                span.tag("result", result);
                
                return result;
            } catch (Exception e) {
                span.tag("error", true);
                span.tag("error.message", e.getMessage());
                throw e;
            } finally {
                span.end();
            }
        }
        
        private String doProcess(String requestId) {
            // 业务处理
            return "success";
        }
    }
    
    // 3. HTTP请求追踪
    @RestController
    public class TracingController {
        
        @Autowired
        private RestTemplate restTemplate;
        
        @Autowired
        private Tracer tracer;
        
        @GetMapping("/api/call")
        public String callService() {
            Span span = tracer.nextSpan().name("call-service").start();
            
            try (Tracer.SpanInScope ws = tracer.withSpanInScope(span)) {
                // 自动注入追踪头
                String result = restTemplate.getForObject("http://other-service/api/data", String.class);
                return result;
            } finally {
                span.end();
            }
        }
    }
    
    // 4. 异步追踪
    @Service
    public class AsyncTracingService {
        
        @Autowired
        private Tracer tracer;
        
        @Async
        public CompletableFuture<String> asyncProcess(String data) {
            Span span = tracer.nextSpan().name("async-process").start();
            
            try (Tracer.SpanInScope ws = tracer.withSpanInScope(span)) {
                // 异步处理
                String result = processData(data);
                return CompletableFuture.completedFuture(result);
            } finally {
                span.end();
            }
        }
        
        private String processData(String data) {
            return "processed: " + data;
        }
    }
}

// 调用链分析
public class TraceAnalysis {
    
    // 1. Zipkin集成
    @Configuration
    public class ZipkinConfig {
        
        @Bean
        public ZipkinReporter zipkinReporter() {
            return AsyncReporter.create(
                OkHttpSender.create("http://zipkin:9411/api/v2/spans")
            );
        }
        
        @Bean
        public Brave brave() {
            return new Brave.Builder("user-service")
                .reporter(zipkinReporter())
                .sampler(Sampler.create(1.0f))
                .build();
        }
    }
    
    // 2. 调用链查询
    @Service
    public class TraceQueryService {
        
        @Autowired
        private ZipkinClient zipkinClient;
        
        // 查询调用链
        public List<Trace> queryTraces(TraceQueryRequest request) {
            QueryRequest queryRequest = QueryRequest.newBuilder()
                .serviceName(request.getServiceName())
                .spanName(request.getSpanName())
                .lookback(request.getLookback())
                .limit(request.getLimit())
                .build();
            
            return zipkinClient.getTraces(queryRequest);
        }
        
        // 查询服务依赖
        public List<DependencyLink> getDependencies(String endTs, String lookback) {
            return zipkinClient.getDependencies(endTs, lookback);
        }
        
        // 查询Span详情
        public Span getSpan(String traceId, String spanId) {
            return zipkinClient.getSpan(traceId, spanId);
        }
    }
    
    // 3. 性能分析
    @Service
    public class PerformanceAnalysis {
        
        @Autowired
        private TraceQueryService traceQueryService;
        
        // 分析慢请求
        public List<SlowRequest> analyzeSlowRequests(String serviceName, long threshold) {
            List<Trace> traces = traceQueryService.queryTraces(
                TraceQueryRequest.builder()
                    .serviceName(serviceName)
                    .lookback(3600000) // 1小时
                    .build()
            );
            
            return traces.stream()
                .flatMap(trace -> trace.getSpans().stream())
                .filter(span -> span.getDuration() > threshold)
                .map(span -> SlowRequest.builder()
                    .traceId(span.getTraceId())
                    .spanId(span.getId())
                    .duration(span.getDuration())
                    .operation(span.getName())
                    .build())
                .collect(Collectors.toList());
        }
        
        // 分析服务依赖
        public ServiceDependencyGraph buildDependencyGraph() {
            List<DependencyLink> dependencies = traceQueryService.getDependencies(
                String.valueOf(System.currentTimeMillis()),
                "3600000"
            );
            
            return ServiceDependencyGraph.builder()
                .dependencies(dependencies)
                .build();
        }
    }
}

// 告警处理服务
@RestController
@RequestMapping("/alerts")
public class AlertHandler {
    
    @Autowired
    private AlertService alertService;
    
    @Autowired
    private NotificationService notificationService;
    
    // 接收告警
    @PostMapping
    public ResponseEntity<Void> handleAlert(@RequestBody Alert alert) {
        // 保存告警
        alertService.saveAlert(alert);
        
        // 发送通知
        notificationService.sendNotification(alert);
        
        // 触发自动化处理
        if (alert.getSeverity() == Severity.CRITICAL) {
            alertService.triggerAutoRemediation(alert);
        }
        
        return ResponseEntity.ok().build();
    }
    
    // 告警处理
    @PostMapping("/{alertId}/resolve")
    public ResponseEntity<Void> resolveAlert(@PathVariable String alertId) {
        alertService.resolveAlert(alertId);
        return ResponseEntity.ok().build();
    }
}

@Service
public class NotificationService {
    
    // 发送通知
    public void sendNotification(Alert alert) {
        // 1. 发送邮件
        sendEmail(alert);
        
        // 2. 发送短信
        if (alert.getSeverity() == Severity.CRITICAL) {
            sendSms(alert);
        }
        
        // 3. 发送钉钉/企业微信
        sendDingTalk(alert);
        
        // 4. 发送Slack
        sendSlack(alert);
    }
    
    private void sendEmail(Alert alert) {
        // 邮件发送逻辑
    }
    
    private void sendSms(Alert alert) {
        // 短信发送逻辑
    }
    
    private void sendDingTalk(Alert alert) {
        // 钉钉通知逻辑
    }
    
    private void sendSlack(Alert alert) {
        // Slack通知逻辑
    }
}

// 告警处理流程
@Service
public class AlertProcessingService {
    
    @Autowired
    private AlertRepository alertRepository;
    
    @Autowired
    private RemediationService remediationService;
    
    // 告警处理流程
    @Transactional
    public void processAlert(Alert alert) {
        // 1. 告警去重
        if (isDuplicate(alert)) {
            updateExistingAlert(alert);
            return;
        }
        
        // 2. 告警分级
        Severity severity = classifySeverity(alert);
        alert.setSeverity(severity);
        
        // 3. 保存告警
        alertRepository.save(alert);
        
        // 4. 告警路由
        routeAlert(alert);
        
        // 5. 自动化处理
        if (canAutoRemediate(alert)) {
            remediationService.autoRemediate(alert);
        }
    }
    
    // 告警去重
    private boolean isDuplicate(Alert alert) {
        return alertRepository.existsByFingerprint(alert.getFingerprint());
    }
    
    // 告警分级
    private Severity classifySeverity(Alert alert) {
        // 根据规则分类
        if (alert.getLabels().containsKey("severity")) {
            return Severity.valueOf(alert.getLabels().get("severity"));
        }
        
        // 默认分级逻辑
        if (alert.getAnnotations().containsKey("critical")) {
            return Severity.CRITICAL;
        }
        
        return Severity.WARNING;
    }
    
    // 告警路由
    private void routeAlert(Alert alert) {
        // 根据告警类型路由到不同的处理组
        String route = determineRoute(alert);
        alert.setRoute(route);
    }
    
    // 自动化处理
    private boolean canAutoRemediate(Alert alert) {
        // 判断是否可以自动处理
        return alert.getSeverity() == Severity.CRITICAL 
            && alert.getType() == AlertType.AUTO_REMEDIABLE;
    }
}

@Service
public class RemediationService {
    
    // 自动化修复
    public void autoRemediate(Alert alert) {
        switch (alert.getType()) {
            case HIGH_CPU:
                scaleOut(alert);
                break;
            case HIGH_MEMORY:
                restartService(alert);
                break;
            case SERVICE_DOWN:
                restartService(alert);
                break;
            default:
                // 无法自动处理
                break;
        }
    }
    
    // 扩容
    private void scaleOut(Alert alert) {
        // 扩容逻辑
    }
    
    // 重启服务
    private void restartService(Alert alert) {
        // 重启服务逻辑
    }
}

// 统一可观测性平台
@SpringBootApplication
public class ObservabilityPlatform {
    
    public static void main(String[] args) {
        SpringApplication.run(ObservabilityPlatform.class, args);
    }
    
    // 统一查询接口
    @RestController
    @RequestMapping("/api/observability")
    public class ObservabilityController {
        
        @Autowired
        private LogService logService;
        
        @Autowired
        private MetricsService metricsService;
        
        @Autowired
        private TraceService traceService;
        
        // 统一查询
        @PostMapping("/query")
        public ObservabilityResult query(@RequestBody ObservabilityQuery query) {
            ObservabilityResult result = new ObservabilityResult();
            
            // 查询日志
            if (query.isIncludeLogs()) {
                result.setLogs(logService.searchLogs(query.getLogQuery()));
            }
            
            // 查询指标
            if (query.isIncludeMetrics()) {
                result.setMetrics(metricsService.queryMetrics(query.getMetricsQuery()));
            }
            
            // 查询链路
            if (query.isIncludeTraces()) {
                result.setTraces(traceService.queryTraces(query.getTraceQuery()));
            }
            
            return result;
        }
        
        // 关联查询
        @GetMapping("/correlate")
        public CorrelationResult correlate(
            @RequestParam String traceId,
            @RequestParam(required = false) String spanId
        ) {
            // 根据TraceId关联日志、指标、链路
            Trace trace = traceService.getTrace(traceId);
            List<LogEntry> logs = logService.searchLogsByTraceId(traceId);
            List<Metric> metrics = metricsService.queryMetricsByTraceId(traceId);
            
            return CorrelationResult.builder()
                .trace(trace)
                .logs(logs)
                .metrics(metrics)
                .build();
        }
    }
    
    // 数据关联服务
    @Service
    public class CorrelationService {
        
        // 关联TraceId
        public void correlateByTraceId(String traceId) {
            // 在日志中添加TraceId
            // 在指标中添加TraceId
            // 在链路中关联日志和指标
        }
        
        // 关联RequestId
        public void correlateByRequestId(String requestId) {
            // 通过RequestId关联所有数据
        }
    }
}

// 数据关联实现
public class DataCorrelation {
    
    // 1. TraceId注入
    @Component
    public class TraceIdInterceptor implements HandlerInterceptor {
        
        @Override
        public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
            // 从请求头获取TraceId
            String traceId = request.getHeader("X-Trace-Id");
            if (traceId == null) {
                traceId = UUID.randomUUID().toString();
            }
            
            // 设置到MDC
            MDC.put("traceId", traceId);
            MDC.put("requestId", UUID.randomUUID().toString());
            
            // 添加到响应头
            response.setHeader("X-Trace-Id", traceId);
            
            return true;
        }
        
        @Override
        public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {
            MDC.clear();
        }
    }
    
    // 2. 日志关联
    @Component
    public class LogCorrelation {
        
        // 日志格式包含TraceId
        // logback-spring.xml
        /*
        <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] [%X{traceId}] [%X{requestId}] %-5level %logger{36} - %msg%n</pattern>
        */
    }
    
    // 3. 指标关联
    @Component
    public class MetricsCorrelation {
        
        @Autowired
        private MeterRegistry meterRegistry;
        
        // 指标标签包含TraceId
        public void recordMetricWithTraceId(String metricName, String traceId, double value) {
            meterRegistry.counter(metricName, "traceId", traceId).increment(value);
        }
    }
    
    // 4. 关联查询
    @Service
    public class CorrelationQueryService {
        
        @Autowired
        private ElasticsearchClient elasticsearchClient;
        
        @Autowired
        private PrometheusClient prometheusClient;
        
        @Autowired
        private ZipkinClient zipkinClient;
        
        // 根据TraceId关联查询
        public CorrelationResult queryByTraceId(String traceId) {
            // 查询日志
            List<LogEntry> logs = searchLogsByTraceId(traceId);
            
            // 查询指标
            List<Metric> metrics = queryMetricsByTraceId(traceId);
            
            // 查询链路
            Trace trace = zipkinClient.getTrace(traceId);
            
            return CorrelationResult.builder()
                .traceId(traceId)
                .logs(logs)
                .metrics(metrics)
                .trace(trace)
                .build();
        }
        
        private List<LogEntry> searchLogsByTraceId(String traceId) {
            SearchRequest searchRequest = SearchRequest.of(s -> s
                .index("logs-*")
                .query(q -> q.match(m -> m.field("traceId").query(traceId)))
            );
            
            SearchResponse<LogEntry> response = elasticsearchClient.search(searchRequest, LogEntry.class);
            return response.hits().hits().stream()
                .map(hit -> hit.source())
                .collect(Collectors.toList());
        }
        
        private List<Metric> queryMetricsByTraceId(String traceId) {
            // 查询Prometheus指标
            String query = String.format("metrics_total{traceId=\"%s\"}", traceId);
            return prometheusClient.query(query);
        }
    }
}

// 完整可观测性建设案例
@SpringBootApplication
public class CompleteObservabilitySetup {
    
    public static void main(String[] args) {
        SpringApplication app = new SpringApplication(CompleteObservabilitySetup.class);
        
        // 启用可观测性
        app.setAdditionalProfiles("observability");
        
        ConfigurableApplicationContext context = app.run(args);
    }
    
    // 可观测性配置
    @Configuration
    @Profile("observability")
    public class ObservabilityConfig {
        
        // 1. 日志配置
        @Bean
        public LoggingSystemCustomizer loggingSystemCustomizer() {
            return loggingSystem -> {
                // 配置结构化日志
                // 配置日志输出到文件
                // 配置日志聚合
            };
        }
        
        // 2. 指标配置
        @Bean
        public MeterRegistryCustomizer<MeterRegistry> metricsCustomizer() {
            return registry -> {
                registry.config().commonTags(
                    "application", "user-service",
                    "environment", "production"
                );
            };
        }
        
        // 3. 链路追踪配置
        @Bean
        public Sampler traceSampler() {
            // 采样率配置
            return Sampler.create(1.0f);
        }
        
        // 4. 健康检查配置
        @Bean
        public HealthIndicator customHealthIndicator() {
            return new CustomHealthIndicator();
        }
    }
    
    // 可观测性拦截器
    @Component
    public class ObservabilityInterceptor implements HandlerInterceptor {
        
        @Autowired
        private MeterRegistry meterRegistry;
        
        @Autowired
        private Tracer tracer;
        
        @Override
        public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
            // 创建Span
            Span span = tracer.nextSpan()
                .name("http-request")
                .tag("method", request.getMethod())
                .tag("path", request.getRequestURI())
                .start();
            
            request.setAttribute("span", span);
            request.setAttribute("startTime", System.currentTimeMillis());
            
            return true;
        }
        
        @Override
        public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {
            Span span = (Span) request.getAttribute("span");
            Long startTime = (Long) request.getAttribute("startTime");
            
            if (span != null) {
                long duration = System.currentTimeMillis() - startTime;
                
                // 记录指标
                meterRegistry.counter("http_requests_total",
                    "method", request.getMethod(),
                    "path", request.getRequestURI(),
                    "status", String.valueOf(response.getStatus())
                ).increment();
                
                meterRegistry.timer("http_request_duration_seconds",
                    "method", request.getMethod(),
                    "path", request.getRequestURI()
                ).record(duration, TimeUnit.MILLISECONDS);
                
                // 记录Span
                span.tag("status", String.valueOf(response.getStatus()));
                span.tag("duration", String.valueOf(duration));
                
                if (ex != null) {
                    span.tag("error", true);
                    span.tag("error.message", ex.getMessage());
                }
                
                span.end();
            }
        }
    }
    
    // 可观测性服务
    @Service
    public class ObservabilityService {
        
        @Autowired
        private LogService logService;
        
        @Autowired
        private MetricsService metricsService;
        
        @Autowired
        private TraceService traceService;
        
        @Autowired
        private AlertService alertService;
        
        // 统一查询
        public ObservabilityDashboard getDashboard(String serviceName, String timeRange) {
            // 查询日志
            LogStats logStats = logService.getLogStats(serviceName, timeRange);
            
            // 查询指标
            MetricsStats metricsStats = metricsService.getMetricsStats(serviceName, timeRange);
            
            // 查询链路
            TraceStats traceStats = traceService.getTraceStats(serviceName, timeRange);
            
            // 查询告警
            List<Alert> alerts = alertService.getActiveAlerts(serviceName);
            
            return ObservabilityDashboard.builder()
                .serviceName(serviceName)
                .timeRange(timeRange)
                .logStats(logStats)
                .metricsStats(metricsStats)
                .traceStats(traceStats)
                .alerts(alerts)
                .build();
        }
    }
}