EFK+DeepSeek 智能运维方案：技术架构与实施步骤 原创

# 使用的基础镜像
 FROM fluent/fluentd:edge-debian
 # 切换用户为root方便接下来执行安装命令
 USER root
 # 安装系统依赖
 RUN apt-get update && \
 apt-get install -y curl && \
 rm -rf /var/lib/apt/lists/*

 # 卸载可能存在的高版本 Elasticsearch gem
 RUN gem uninstall elasticsearch elasticsearch-api -a -x || true

 # 安装指定版本 gem 和 Fluentd Elasticsearch 插件
 RUN gem install elasticsearch -v 8.17.1 --no-document && \
 gem install elasticsearch-api -v 8.17.1 --no-document && \
 gem install fluent-plugin-elasticsearch -v 5.4.3 --no-document
 USER fluent

# 定义本文件中所有要启动的服务（容器）
 services:
 # Fluent Bit：轻量收集容器日志
 # 【服务名】是的，'fluent-bit' 就是这个服务的名称。它在 Docker Compose 网络内部被识别为此名。
 fluent-bit:
 # 使用的镜像：从 Docker Hub 拉取最新的 Fluent Bit 官方镜像
 image: fluent/fluent-bit:latest
 # 指定容器启动后的名称，通过 `docker ps` 等命令可以看到这个名字
 container_name: fluent-bit
 # 依赖关系：指定此服务的启动依赖于另一个服务 'fluentd'
 depends_on:
 fluentd:
 # 条件：只有当 'fluentd' 服务通过健康检查（healthy）后，才会启动 fluent-bit
 condition: service_healthy
 # 端口映射：将宿主机的端口映射到容器内的端口
 # 格式 - "宿主机端口:容器端口"
 ports:
 - "2020:2020" # 将容器内的 2020 端口（Fluent Bit 的 HTTP Server，常用于健康检查或监控）映射到宿主机的 2020 端口
 # 数据卷挂载：将宿主机的目录或文件挂载到容器内，实现数据持久化或配置注入
 volumes:
 # 将宿主机的 '/Users/cuihao/docker/EFK/web-logs' 目录挂载到容器内的 '/var/log/' 目录。
 # Fluent Bit 会监控这个目录下的日志文件变化，并收集新产生的日志。
 #/var/log/metric_log
 #/Users/cuihao/docker/EFK/web-logs
 - /Users/cuihao/docker/EFK/web-logs:/var/log/
 # 将宿主机的 Fluent Bit 主配置文件挂载到容器内，替代镜像内的默认配置。
 # 这个文件定义了数据输入（Input）、处理（Parser, Filter）和输出（Output）的规则。
 - /Users/cuihao/docker/EFK/fluent-bit/etc/:/fluent-bit/etc/

 # Fluentd：格式化
 # 【服务名】'fluentd' 是这个服务的名称。
 fluentd:
 container_name: fluent
 # 不是使用现成的镜像，而是通过指定构建上下文路径（E:\EFK\fluentd）来构建自定义镜像。
 # 该路径下应该有一个名为 'Dockerfile' 的文件，默认读取 'Dockerfile' 文件。
 build: /Users/cuihao/docker/EFK/fluentd
 volumes:
 # 将宿主机上的 Fluentd 配置目录挂载到容器内，使配置变更无需重新构建镜像。
 - /Users/cuihao/docker/EFK/fluentd/conf:/fluentd/etc
 depends_on:
 elasticsearch:
 condition: service_healthy
 ports:
 - "24224:24224" # Fluentd 默认的 TCP 端口，用于接收来自 Fluent Bit 或其他客户端转发来的日志，这个端口会配置到fluent-bit的OUTPUT中
 - "24224:24224/udp" # Fluentd 默认的 UDP 端口，用途同上
 - "24220:24220" # Fluentd 的健康检查 API 端口
 # 健康检查配置：Docker 会根据此规则判断容器是否正常启动
 healthcheck:
 test: ["CMD-SHELL", "curl -fs http://localhost:24220/api/plugins.json || exit 1"] # 检查健康检查端点是否返回成功
 interval: 5s # 每 5 秒检查一次
 timeout: 3s # 每次检查超时时间为 3 秒
 retries: 5 # 连续失败 5 次才标记为不健康
 start_period: 10s # 容器启动后，等待 10 秒再进行第一次健康检查

 # Elasticsearch：存储日志
 # 【服务名】'elasticsearch' 是这个服务的名称。
 elasticsearch:
 image: docker.elastic.co/elasticsearch/elasticsearch:8.17.1 # 使用 Elastic 官方的 8.17.1 版本镜像
 container_name: elasticsearch
 hostname: elasticsearch # 设置容器内部的主机名，在集群中很有用
 environment:
 - discovery.type=single-node # 设置为单节点模式，适合开发和测试
 - xpack.security.enabled=false # 关闭 X-Pack 安全功能（用户认证、HTTPS等）。生产环境必须开启，但测试时关闭更简单。
 healthcheck:
 test: ["CMD", "curl", "-f", "http://localhost:9200/_cluster/health"] # 检查 ES 集群健康状态 API
 interval: 10s
 retries: 5
 timeout: 5s
 ports:
 - "9200:9200" # 将 ES 的 HTTP REST API 端口映射到宿主机，方便通过浏览器或命令访问

 # Kibana：日志可视化
 # 【服务名】'kibana' 是这个服务的名称。
 kibana:
 container_name: kibana
 image: docker.elastic.co/kibana/kibana:8.17.1 # Kibana 版本需要与 Elasticsearch 版本一致
 depends_on:
 elasticsearch:
 condition: service_healthy # 等待 Elasticsearch 健康后再启动
 ports:
 - "5601:5601" # 将 Kibana 的 Web 界面端口映射到宿主机，通过 http://localhost:5601 访问

docker compose -f /Users/cuihao/docker/EFK/docker-compose.yml up -d

=> ERROR [fluentd internal] load metadata for docker.io/fluent/fluentd:edge-debian 31.1s
 ------
 > [fluentd internal] load metadata for docker.io/fluent/fluentd:edge-debian:
 ------
 failed to solve: DeadlineExceeded: DeadlineExceeded: DeadlineExceeded: fluent/fluentd:edge-debian: failed to resolve source metadata for docker.io/fluent/fluentd:edge-debian: failed to authorize: DeadlineExceeded: failed to fetch anonymous token: Get "https://auth.docker.io/token?scope=repository%3Afluent%2Ffluentd%3Apull&service=registry.docker.io": dial tcp 75.126.124.162:443: i/o timeout

docker pull fluent/fluentd:edge-debian

docker compose -f /Users/cuihao/docker/EFK/docker-compose.yml up -d

##############################################
 # 输入插件配置（收集日志）
 ##############################################

 # 输入源1：采集cpu日志文件
 [INPUT]
 # 使用 tail 插件监控文件变化
 Name tail
 # 自定义标签，标识为系统指标类日志
 Tag sys.metric 
 # 系统指标日志文件路径（可能是由其他工具生成的指标数据）
 Path /var/log/metric_log
 # 检查文件变化的间隔时间（秒）
 Refresh_Interval 10 

 ##############################################
 # 输出插件（转发到 Fluentd）
 ##############################################
 [OUTPUT]
 # 使用 forward 插件将日志转发到Fluentd聚合器
 Name forward
 # 匹配所有标签的日志（* 是通配符，表示所有输入源）
 Match *
 # Fluentd 服务地址（使用Docker Compose服务名进行服务发现）
 Host fluentd
 # Fluentd 监听端口（forward插件的默认端口）
 Port 24224
 # 网络故障时的最大重试次数，防止无限重试消耗资源
 Retry_Limit 10

 # 输出源2：同时输出到控制台（用于调试和监控）
 [OUTPUT]
 # 使用 stdout 插件在控制台打印日志
 Name stdout
 # 匹配所有标签的日志
 Match *
 # 注意：生产环境通常应注释或移除此输出，避免日志重复和性能开销

###############################
 # Fluentd 健康检查（monitor_agent）
 ###############################
 <source>
 @type monitor_agent # 启用监控代理插件，用于收集Fluentd自身运行指标
 bind 0.0.0.0 # 监听所有网络接口
 port 24220 # 监控服务端口，可通过此端口获取Fluentd运行状态信息
 </source>

 ###############################
 # Fluentd 日志输入（forward）
 ###############################
 <source>
 @type forward # 启用forward输入插件，接收来自Fluent-bit或其他Fluentd节点的日志
 port 24224 # 转发协议监听端口
 bind 0.0.0.0 # 监听所有网络接口
 </source>

 ###############################
 # 处理 collectd 采集的CPU指标数据
 ###############################
 # 第一步：提取log字段中write_log后的JSON部分（现有配置）
 <filter sys.metric> # 过滤系统指标数据
 @type parser # 使用解析器插件
 key_name log # 解析log字段内容
 reserve_data true # 保留所有原始字段
 remove_key_name_field false # 不移除原始的key_name字段
 <parse>
 @type regexp # 使用正则表达式解析
 # 正则表达式匹配collectd的CPU数据格式，使用命名捕获组提取CPU信息
 expression /write_log values:(?:#012|\s)*(?<log>\[\{.*?\}\])/ # 非贪婪匹配确保只取一个数组

 time_key time # 指定时间字段
 time_type float # 时间格式为浮点数（Unix时间戳）
 </parse>
 </filter>

 # 第二步：将log字段的JSON字符串解析为JSON对象
 <filter sys.metric>
 @type parser
 key_name log # 解析第一步提取的log字段（此时是JSON字符串）
 reserve_data true # 保留所有字段
 remove_key_name_field false # 保留解析后的log字段
 <parse>
 @type json # 用JSON解析器处理
 json_parser json # 使用默认JSON解析器
 array true # 强制将JSON数组字符串解析为数组对象
 </parse>
 </filter>

 # 第三步：标记异常日志（增加详细调试字段）
 <filter sys.metric>
 @type record_transformer
 enable_ruby true
 <record>
 # 直接判断 values[0] 是否大于 80
 status ${(record["plugin"] == "cpu" && record["type"] == "percent" && record["values"].is_a?(Array) && !record["values"].empty? && record["values"][0].to_f > 80) ? "abnormal" : "normal"}

 debug_plugin ${record["plugin"].to_s}
 debug_type ${record["type"].to_s}
 debug_values_content ${record["values"].inspect}
 </record>
 </filter>

 ###############################
 # 输出到 Elasticsearch 8、stdout 和 HTTP端点
 ###############################
 <match *.**> # 匹配所有标签的日志Tag
 @type copy # 复制插件，将日志同时发送到多个输出目的地

 # 第一个输出目标：Elasticsearch
 <store>
 @id es_output
 @type elasticsearch # 输出到Elasticsearch
 host elasticsearch # ES主机地址（可以是主机名或IP）
 port 9200 # ES服务端口
 scheme http # 使用HTTP协议
 logstash_format true # 使用Logstash格式索引命名
 logstash_prefix fluentd-${tag} # 索引前缀加上标签名
 logstash_dateformat %Y%m%d # 索引日期格式年月日
 include_tag_key true # 在输出中包含标签字段
 tag_key @log_name # 标签字段的键名
 flush_interval 1s # 刷新间隔1秒
 </store>

 <store>
 @id output
 @type stdout # 输出到控制台/stdout
 key status # 字段
 pattern ^normal$ # 正则匹配
 </store>

 <store>
 @type relabel # 使用 relabel 输出插件进行标签重路由
 @label @abnormal # 将所有匹配到的数据重新路由到 @abnormal 标签处理流程
 </store>
 </match>


 ###############################
 # 异常日志输出到 HTTP端点
 ###############################
 <label @abnormal>
 # 这个 filter 块会对所有进入 @abnormal 标签的数据进行过滤
 # 只有通过这个过滤器的数据才会继续流向后面的 match 块
 <filter **>
 @type grep # 使用 grep 过滤器
 <regexp>
 key status # 检查每条记录的 status 字段
 pattern ^abnormal$ # 只保留 status 值为 "abnormal" 的记录
 </regexp>
 </filter>

 # 这个 match 块会接收到经过上面 filter 过滤后的数据
 <match **>
 @id http_output
 @type http # HTTP输出插件
 endpoint http://host.docker.internal:5001/analyze-fluentd-log # 日志分析API端点，host.docker.internal是Docker特殊主机名，指向宿主机
 http_method post # 使用POST方法发送

 <format>
 @type json # 数据格式为JSON
 </format>

 <buffer>
 # 缓冲配置区块：控制数据如何缓冲和重试发送
 # 用于提高网络输出的可靠性和性能，避免频繁的小数据包发送
 
 # 缓冲刷新间隔：每2秒强制刷新一次缓冲区
 # - 即使缓冲区未满，也会每2秒发送一次累积的数据
 # - 平衡实时性和网络效率：太短会增加网络请求，太长会降低实时性
 flush_interval 2s
 
 # 重试策略：使用指数退避算法
 # - 第一次重试等待：基础等待时间
 # - 第二次重试等待：基础时间 × 2
 # - 第三次重试等待：基础时间 × 4，依此类推
 # - 避免网络拥塞时的大量重试导致雪崩效应
 retry_type exponential_backoff
 
 # 基础重试等待时间：第一次重试前等待1秒
 # - 首次重试的初始等待间隔
 # - 后续重试会根据指数退避算法递增
 retry_wait 1s
 
 # 最大重试间隔：单次重试最多等待30秒
 # - 防止指数增长后的等待时间过长
 # - 即使使用指数退避，也不会超过30秒的间隔
 retry_max_interval 30s
 
 # 总重试超时时间：10分钟后放弃重试
 # - 从第一次失败开始计算，10分钟后停止重试
 # - 防止因为长期不可用的目标服务导致无限重试
 # - 超时后数据可能会被丢弃（取决于配置）
 retry_timeout 10m
 </buffer>
 </match>
 </label>

from flask import Flask, request, jsonify, Response
 from openai import AsyncOpenAI
 import os
 import json
 import threading
 import asyncio
 from datetime import datetime
 from dotenv import load_dotenv

 # 加载环境变量
 load_dotenv()

 # 创建Flask应用实例
 app = Flask(__name__)

 # 初始化客户端
 DEEPSEEK_API_KEY = os.getenv("DEEPSEEK_API_KEY")
 if not DEEPSEEK_API_KEY:
 raise ValueError("未找到DEEPSEEK_API_KEY，请在.env文件中配置")

 client = AsyncOpenAI(
 api_key=DEEPSEEK_API_KEY,
 base_url="https://api.deepseek.com"
 )

 # 路径配置
 current_dir = os.path.dirname(os.path.abspath(__file__))
 report_dir = os.path.join(current_dir, "report")
 OUTPUT_REPORT_PATH = os.path.join(report_dir, "incident_report.json")
 ERROR_INFO_PATH = os.path.join(current_dir, "api_error.log")
 OPERATION_LOG_PATH = os.path.join(current_dir, "api_operation.log") # 新增操作日志文件
 os.makedirs(report_dir, exist_ok=True)


 def write_operation_log(message, request_id=None):
 """记录操作日志，包含时间戳和可选的请求ID"""
 timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S.%f")[:-3] # 精确到毫秒
 request_id = request_id or "N/A"
 log_entry = f"[{timestamp}] [REQUEST={request_id}] OPERATION: {message}\n"
 try:
 with open(OPERATION_LOG_PATH, 'a', encoding='utf-8') as f:
 f.write(log_entry)
 print(log_entry.strip()) # 同时输出到控制台
 except Exception as e:
 print(f"[日志系统错误] 写入操作日志失败: {str(e)} | 原始消息: {message}")


 def write_error_log(error_message, request_id=None):
 """记录错误日志，包含时间戳和请求ID"""
 timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S.%f")[:-3]
 request_id = request_id or "N/A"
 log_entry = f"[{timestamp}] [REQUEST={request_id}] ERROR: {error_message}\n"
 try:
 with open(ERROR_INFO_PATH, 'a', encoding='utf-8') as f:
 f.write(log_entry)
 print(log_entry.strip()) # 同时输出到控制台
 except Exception as e:
 print(f"[日志系统错误] 写入错误日志失败: {str(e)} | 原始错误: {error_message}")


 def append_to_json_file(data, timestamp, request_id):
 """将数据追加到JSON文件，带日志记录"""
 try:
 write_operation_log("开始写入分析报告", request_id)

 data_with_timestamp = {
 "timestamp": timestamp,
 "request_id": request_id, # 新增请求ID便于追踪
 **data
 }

 existing_data = []
 if os.path.exists(OUTPUT_REPORT_PATH):
 try:
 with open(OUTPUT_REPORT_PATH, 'r', encoding='utf-8') as f:
 existing_data = json.load(f)
 write_operation_log(f"成功读取现有报告（{len(existing_data)}条记录）", request_id)
 except (json.JSONDecodeError, FileNotFoundError):
 error_msg = "报告文件损坏或不存在，将重新初始化"
 write_error_log(error_msg, request_id)
 existing_data = []

 existing_data.append(data_with_timestamp)

 with open(OUTPUT_REPORT_PATH, 'w', encoding='utf-8') as f:
 json.dump(existing_data, f, ensure_ascii=False, indent=2)

 write_operation_log("分析报告写入成功", request_id)
 return True
 except Exception as e:
 error_msg = f"写入JSON报告文件时出错: {str(e)}"
 write_error_log(error_msg, request_id)
 return False


 async def process_llm_background(log_content, call_timestamp, request_id):
 """后台处理LLM调用，带详细日志"""
 try:
 write_operation_log("开始后台LLM处理流程", request_id)
 
 # 构造提示词
 write_operation_log("开始构建提示词", request_id)
 prompt = f"""
 你是一名系统运维专家。以下是异常日志，请生成根因分析报告：
 日志内容：
 {log_content}

 请输出格式：
 【标题】
 ...
 【异常原因分析】
 ...
 【修复建议】
 ...
 """
 write_operation_log("提示词构建完成，准备调用LLM", request_id)

 # 调用LLM
 write_operation_log("开始调用DeepSeek API", request_id)
 response = await client.chat.completions.create(
 model="deepseek-chat",
 messages=[
 {"role": "system", "content": "你是经验丰富的运维专家，负责分析日志并提供修复建议"},
 {"role": "user", "content": prompt}
 ],
 temperature=0.7,
 max_tokens=800,
 stream=False
 )
 write_operation_log("DeepSeek API调用成功", request_id)

 # 处理结果
 report_text = response.choices[0].message.content
 result_data = {
 "raw_log": log_content,
 "root_cause_report": report_text
 }
 write_operation_log("LLM返回结果解析完成", request_id)
 
 # 保存结果
 if append_to_json_file(result_data, call_timestamp, request_id):
 write_operation_log("分析结果已成功保存到报告文件", request_id)
 else:
 write_error_log("分析结果保存失败", request_id)

 write_operation_log("后台LLM处理流程完成", request_id)

 except Exception as e:
 error_msg = f"LLM调用失败: {str(e)}"
 write_error_log(error_msg, request_id)


 def run_async_task(log_content, call_timestamp, request_id):
 """线程包装器，带日志"""
 try:
 write_operation_log("启动异步任务处理线程", request_id)
 asyncio.run(process_llm_background(log_content, call_timestamp, request_id))
 except Exception as e:
 write_error_log(f"异步任务线程执行失败: {str(e)}", request_id)


 def build_log_content_from_records(records, request_id):
 """构建日志内容，带日志记录"""
 write_operation_log("开始构建日志内容", request_id)
 lines = []
 for i, record in enumerate(records or []):
 if isinstance(record, dict) and ("log" in record):
 value = record.get("log")
 if value is not None and str(value).strip() != "":
 lines.append(str(value))
 write_operation_log(f"成功提取第{i+1}条记录的log字段", request_id)
 else:
 write_operation_log(f"第{i+1}条记录的log字段为空，已忽略", request_id)
 else:
 write_operation_log(f"第{i+1}条记录不包含log字段，已忽略", request_id)
 
 log_content = "\n".join(lines).strip()
 write_operation_log(f"日志内容构建完成，共包含{len(lines)}条有效记录", request_id)
 return log_content


 @app.route('/analyze-fluentd-log', methods=['POST'])
 def analyze_fluentd_log():
 """主接口：带详细日志记录的请求处理"""
 # 生成唯一请求ID，便于全流程追踪
 request_id = datetime.now().strftime("%Y%m%d%H%M%S") + f"-{os.urandom(4).hex()}"
 write_operation_log("收到新的请求", request_id)

 try:
 # 1. 记录请求基本信息
 call_timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
 write_operation_log(f"请求方法: {request.method}, 客户端IP: {request.remote_addr}, Content-Type: {request.content_type}", request_id)

 # 2. 验证请求类型
 if request.content_type != "application/x-ndjson":
 error_msg = f"不支持的Content-Type: {request.content_type}，仅接受application/x-ndjson"
 write_error_log(error_msg, request_id)
 return jsonify({
 "error": error_msg,
 "request_id": request_id
 }), 415

 # 3. 解析NDJSON数据
 write_operation_log("开始解析NDJSON数据", request_id)
 ndjson_data = request.data.decode().splitlines()
 records = []
 for i, line in enumerate(ndjson_data):
 if line.strip():
 try:
 record = json.loads(line)
 records.append(record)
 write_operation_log(f"成功解析第{i+1}行NDJSON数据", request_id)
 except json.JSONDecodeError as e:
 error_msg = f"第{i+1}行NDJSON解析失败: {str(e)}"
 write_error_log(error_msg, request_id)
 records.append({"message": line, "parse_error": str(e)})
 else:
 write_operation_log(f"第{i+1}行是空白行，已忽略", request_id)
 write_operation_log(f"NDJSON数据解析完成，共{len(records)}条记录", request_id)

 # 4. 过滤有效日志记录
 write_operation_log("开始过滤有效日志记录", request_id)
 log_records = [r for r in records if isinstance(r, dict) and 'log' in r and str(r.get('log', '')).strip()]
 write_operation_log(f"有效日志记录过滤完成: {len(log_records)}/{len(records)}", request_id)
 
 if not log_records:
 error_msg = "未找到有效日志记录（缺少log字段）"
 write_error_log(error_msg, request_id)
 return Response(
 json.dumps({
 "status": "ignored",
 "reason": error_msg,
 "raw_records_count": len(records),
 "request_id": request_id
 }, ensure_ascii=False, indent=2),
 mimetype="application/json"
 )

 # 5. 构建日志内容
 log_content = build_log_content_from_records(log_records, request_id)
 if not log_content:
 error_msg = "日志内容为空"
 write_error_log(error_msg, request_id)
 return jsonify({
 "error": error_msg,
 "request_id": request_id
 }), 400

 # 6. 参数验证通过，准备启动后台任务
 write_operation_log("参数验证通过，准备启动后台处理任务", request_id)

 # 7. 启动后台线程处理LLM调用
 thread = threading.Thread(
 target=run_async_task,
 args=(log_content, call_timestamp, request_id),
 daemnotallow=True
 )
 thread.start()
 write_operation_log("后台处理线程已启动", request_id)

 # 8. 立即返回响应
 response_data = {
 "status": "accepted",
 "message": "请求已接收，正在后台处理",
 "timestamp": call_timestamp,
 "log_records_count": len(log_records),
 "request_id": request_id # 返回请求ID便于追踪
 }
 write_operation_log("请求处理完成，已返回响应", request_id)

 return Response(
 json.dumps(response_data, ensure_ascii=False, indent=2),
 mimetype="application/json",
 status=202
 )

 except Exception as e:
 error_msg = f"参数验证失败: {str(e)}"
 write_error_log(error_msg, request_id)
 return jsonify({
 "error": error_msg,
 "request_id": request_id
 }), 400


 @app.route('/health', methods=['GET'])
 def health_check():
 """健康检查接口，带日志"""
 request_id = f"health-{datetime.now().strftime('%Y%m%d%H%M%S')}"
 write_operation_log("收到健康检查请求", request_id)
 response = jsonify({
 "status": "healthy",
 "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
 "request_id": request_id
 })
 write_operation_log("健康检查响应已返回", request_id)
 return response


 if __name__ == '__main__':
 print("Flask API 启动中...")
 print("环境变量配置:")
 print(f" - 从 .env 文件加载 DEEPSEEK_API_KEY: {'已配置' if DEEPSEEK_API_KEY else '未配置'}")
 print("日志文件路径:")
 print(f" - 操作日志: {OPERATION_LOG_PATH}")
 print(f" - 错误日志: {ERROR_INFO_PATH}")
 print("可用的端点:")
 print(" - POST /analyze-fluentd-log - 接收日志并在后台处理")
 print(" - GET /health - 服务健康检查")
 app.run(host="0.0.0.0", port=5001, debug=True)

import streamlit as st
 import json
 import re
 import os
 from log_generator import LogGenerator

 # 初始化日志生成器
 log_generator = LogGenerator()

 # ========================
 # 读取 JSON 文件
 # ========================
 #file_path = r"report\incident_report.json"
 file_path = os.path.join("report", "incident_report.json")
 # 初始化reports变量
 reports = []

 # 检查文件是否存在和读取数据
 if os.path.exists(file_path) and os.path.getsize(file_path) > 0:
 try:
 with open(file_path, "r", encoding="utf-8") as f:
 reports = json.load(f)
 except json.JSONDecodeError as e:
 st.sidebar.error(f"JSON文件格式错误: {e}")
 except Exception as e:
 st.sidebar.error(f"读取文件时发生错误: {e}")
 else:
 if not os.path.exists(file_path):
 st.sidebar.warning(f"📁 文件 {file_path} 不存在")
 else:
 st.sidebar.warning(f"📄 文件 {file_path} 为空")

 # ========================
 # 提取标题（标题在【标题】后的下一行）
 # ========================
 def extract_title(report_text):
 # 去掉空行，逐行处理
 lines = [line.strip() for line in report_text.splitlines() if line.strip()]
 for i, line in enumerate(lines):
 if line.startswith("【标题】"):
 # 找到【标题】，取下一行作为真正的标题
 if i + 1 < len(lines):
 return lines[i + 1].strip()
 else:
 return "未命名报告"
 return "未命名报告"

 # ========================
 # 按【字段】分段解析报告
 # 例如：分出 "异常原因分析"、"修复建议"、"异常日志"
 # ========================
 def split_sections(report_text):
 sections = {}
 # 用正则把【xxx】作为分隔符拆开
 parts = re.split(r"(【.*?】)", report_text)
 current_key = None
 for part in parts:
 if not part.strip():
 continue
 if part.startswith("【") and part.endswith("】"):
 # 当前是一个小节标题，例如【异常原因分析】
 current_key = part.strip("【】")
 sections[current_key] = ""
 else:
 # 当前是小节内容
 if current_key:
 sections[current_key] += part.strip() + "\n"
 return sections

 # ========================
 # 侧边栏：搜索功能
 # ========================
 st.sidebar.title("异常报告列表")

 # 如果没有报告数据，显示提示信息
 if not reports:
 st.sidebar.info("📊 暂无报告数据")
 # 右侧主内容区域显示友好提示
 st.title("📊 异常报告系统")
 st.info("""
 ## 欢迎使用异常报告系统！
 
 ### 📁 当前状态
 - 报告数据文件未找到或为空
 - 请确保 `report/incident_report.json` 文件存在且包含有效数据
 
 ### 🔧 如何添加数据
 1. 在 `report` 文件夹中创建 `incident_report.json` 文件
 2. 按照以下格式添加报告数据：
 ```json
 [
 {
 "timestamp": "2024-01-01 10:00:00",
 "raw_log": "日志内容...",
 "root_cause_report": "【标题】\n报告标题\n【异常原因分析】\n分析内容..."
 }
 ]
 ```
 
 ### 💡 功能说明
 - 支持按时间倒序查看报告
 - 支持搜索报告内容
 - 自动解析报告结构并展示
 """)
 st.stop()

 # 倒序排序：最新的报告排在最前面
 reports_sorted = sorted(reports, key=lambda x: x["timestamp"], reverse=True)

 # 添加搜索输入框
 search_query = st.sidebar.text_input("🔍 搜索报告内容（标题/日志/分析/建议）").strip()

 # 判断一条报告是否匹配搜索条件
 def report_matches(report, query):
 if not query:
 return True
 query = query.lower()
 if query in extract_title(report["root_cause_report"]).lower():
 return True
 if query in report["raw_log"].lower():
 return True
 if query in report["root_cause_report"].lower():
 return True
 return False

 # 根据搜索条件过滤报告
 filtered_reports = [r for r in reports_sorted if report_matches(r, search_query)]

 # 构建侧边栏显示内容（报告生成时间 | 标题）
 sidebar_items = [
 f"{r['timestamp']} | {extract_title(r['root_cause_report'])}" for r in filtered_reports
 ]

 # 没有结果时提示
 if not sidebar_items:
 st.sidebar.warning("未找到匹配的报告")
 st.stop()

 # 侧边栏选择框
 selected_item = st.sidebar.radio("选择报告", sidebar_items)

 # ========================
 # 侧边栏：测试区域
 # ========================
 st.sidebar.markdown("---")
 st.sidebar.subheader("🧪 测试数据生成")

 # 日志类型选择
 log_type = st.sidebar.radio(
 "选择日志类型",
 ["CPU"],
 help="CPU: 生成CPU使用率日志",
 )

 # CPU使用率输入（仅在选择CPU类型时显示）
 cpu_usage = None
 if log_type == "CPU":
 cpu_usage = st.sidebar.number_input(
 "CPU使用率 (%)",
 min_value=0.1,
 max_value=100.0,
 value=85.0,
 step=0.1,
 help="输入0.1-100之间的CPU使用率值"
 )

 # 生成按钮
 if st.sidebar.button(f"生成{log_type}日志", type="primary"):
 with st.spinner("正在生成日志..."):
 result = log_generator.generate_and_save_log(log_type.lower(), cpu_usage)
 
 if result['status'] == 'success':
 st.sidebar.success(result['message'])
 st.sidebar.info(f"日志文件: {result['log_file']}")
 if 'log_content_preview' in result:
 st.sidebar.code(result['log_content_preview'], language="text")
 else:
 st.sidebar.error(result['message'])

 # 根据选择找到对应的报告
 selected_index = sidebar_items.index(selected_item)
 selected_report = filtered_reports[selected_index]

 # 提取报告标题
 report_title = extract_title(selected_report["root_cause_report"])

 # ========================
 # 右侧内容展示
 # ========================
 st.title(report_title)
 st.subheader(f"**报告生成时间**: {selected_report['timestamp']}")

 # ---- 原始日志（默认折叠） ----
 with st.expander("原始日志", expanded=False):
 st.code(selected_report["raw_log"], language="text")

 # ---- 根因分析报告 ----
 sections = split_sections(selected_report["root_cause_report"])
 # 去掉【标题】部分，避免重复展示
 sections.pop("标题", None)


 for key, value in sections.items():
 st.subheader(key) # 小节标题，例如 “异常原因分析” st.markdown(value.strip()) # 小节内容

python process_log.py

Flask API 启动中...
 环境变量配置:
 - 从 .env 文件加载 DEEPSEEK_API_KEY: 已配置
 日志文件路径:
 - 操作日志: /Users/cuihao/docker/EFK/api_operation.log
 - 错误日志: /Users/cuihao/docker/EFK/api_error.log
 可用的端点:
 - POST /analyze-fluentd-log - 接收日志并在后台处理
 - GET /health - 服务健康检查
 * Serving Flask app "process_log" (lazy loading)

streamlit run log_ui.py