mcp-log-query-server 1.0.0 → 2.1.1

package/config.js

@@ -1,10 +1,11 @@
 /**
  * Log Query MCP Server - 配置文件
- * 
+ *
  * 包含：
  * - 堡垒机连接信息
  * - K8s 服务器信息
  * - 服务/容器映射
+ * - Grafana Loki 生产环境配置
  */
 
 // 堡垒机配置 - 从环境变量读取
@@ -471,4 +472,164 @@ export function detectContextFromPath(workspacePath) {
 function findServiceByName(serviceName) {
   const lower = serviceName.toLowerCase();
   return SERVICES[lower] || null;
+}
+
+
+// ============================================================
+// Grafana Loki 生产环境配置
+// ============================================================
+
+/**
+ * Loki 默认参数
+ */
+export const LOKI_DEFAULTS = {
+  // 默认查询时间范围：1 小时（毫秒）
+  defaultTimeRange: 60 * 60 * 1000,
+  // 默认最大返回行数
+  maxLines: 100,
+  // 默认项目名
+  defaultProject: 'senior'
+};
+
+/**
+ * Loki 环境配置
+ * 支持多个 Grafana/Loki 实例（CMS 生产、私有化部署等）
+ *
+ * 每个环境包含：
+ * - grafanaUrl: Grafana 地址
+ * - datasourceUid: Loki 数据源 UID
+ * - datasourceId: Loki 数据源 ID
+ * - orgId: Grafana 组织 ID
+ * - username/password: 认证信息（可选）
+ * - defaultProject: 默认项目名
+ * - description: 环境描述
+ */
+export const LOKI_ENVIRONMENTS = {
+  // CMS 生产环境（华为云）— 有 project 标签
+  'cms': {
+    description: 'CMS 生产环境（华为云）',
+    grafanaUrl: process.env.MCP_GRAFANA_URL || 'http://10.6.14.2:3000',
+    datasourceUid: process.env.MCP_GRAFANA_LOKI_UID || 'af2718a2-9c32-4364-a495-3bb29035199c',
+    datasourceId: parseInt(process.env.MCP_GRAFANA_DATASOURCE_ID || '35'),
+    orgId: parseInt(process.env.MCP_GRAFANA_ORG_ID || '1'),
+    username: process.env.MCP_GRAFANA_USER || 'loki',
+    password: process.env.MCP_GRAFANA_PASSWORD || 'nihao123!!',
+    defaultProject: 'senior',
+    hasProjectLabel: true   // CMS 有 project 标签，可用 {project="senior"} 查询
+  },
+
+  // ---- 私有化环境（均无 project 标签，通过 filename 正则匹配） ----
+
+  // 城阳私有化
+  'chengyang': {
+    description: '城阳私有化环境',
+    grafanaUrl: 'https://cyjy-iot.chengyang.gov.cn/journals-loki',
+    datasourceUid: 'f17c8456-9ef4-4f44-9292-366681ac4f0c',
+    datasourceId: 1,
+    orgId: 1,
+    username: 'loki',
+    password: 'nihao123!!',
+    defaultProject: 'senior',
+    hasProjectLabel: false  // 无 project 标签，用 filename 正则匹配
+  },
+
+  // 临颖私有化
+  'linying': {
+    description: '临颖私有化环境',
+    grafanaUrl: 'https://zhyl-linying.cn/journals-loki',
+    datasourceUid: 'ae7df92c-e2d8-4fca-ac47-80d9c97aec95',
+    datasourceId: 1,
+    orgId: 1,
+    username: 'loki',
+    password: 'nihao123!!',
+    defaultProject: 'senior',
+    hasProjectLabel: false
+  },
+
+  // 漯河私有化
+  'luohe': {
+    description: '漯河私有化环境',
+    grafanaUrl: 'https://zhyl.mzj.luohe.gov.cn/journals-loki',
+    datasourceUid: 'e527a5a6-0cf7-43de-8476-d9a00e0aa075',
+    datasourceId: 1,
+    orgId: 1,
+    username: 'loki',
+    password: 'nihao123!!',
+    defaultProject: 'senior',
+    hasProjectLabel: false
+  },
+
+  // 德阳私有化
+  'deyang': {
+    description: '德阳私有化环境',
+    grafanaUrl: 'https://www.deyangyinfa.com/journals-loki',
+    datasourceUid: 'c628c402-062f-4ed0-ad32-b3c8aa7cec90',
+    datasourceId: 2,
+    orgId: 1,
+    username: 'loki',
+    password: 'nihao123!!',
+    defaultProject: 'senior',
+    hasProjectLabel: false
+  }
+};
+
+/**
+ * Loki 环境别名映射
+ * 支持用户使用简称来指定环境
+ */
+export const LOKI_ENV_ALIASES = {
+  // CMS
+  'prod': 'cms',
+  'production': 'cms',
+  '生产': 'cms',
+  '生产环境': 'cms',
+  'cms': 'cms',
+  // 城阳
+  '城阳': 'chengyang',
+  'chengyang': 'chengyang',
+  'cy': 'chengyang',
+  // 临颖
+  '临颖': 'linying',
+  'linying': 'linying',
+  'ly': 'linying',
+  // 漯河
+  '漯河': 'luohe',
+  'luohe': 'luohe',
+  'lh': 'luohe',
+  // 德阳
+  '德阳': 'deyang',
+  'deyang': 'deyang',
+  'dy': 'deyang'
+};
+
+/**
+ * 根据名称或别名获取 Loki 环境配置
+ * @param {string} envName - 环境名称或别名
+ * @returns {Object|null} 环境配置
+ */
+export function getLokiEnvironment(envName) {
+  if (!envName) return null;
+  const normalizedName = LOKI_ENV_ALIASES[envName.toLowerCase()] || envName.toLowerCase();
+  return LOKI_ENVIRONMENTS[normalizedName] || null;
+}
+
+/**
+ * 判断是否为 Loki 环境请求
+ * @param {string} env - 环境参数
+ * @returns {boolean}
+ */
+export function isLokiEnv(env) {
+  if (!env) return false;
+  const normalizedName = LOKI_ENV_ALIASES[env.toLowerCase()] || env.toLowerCase();
+  return !!LOKI_ENVIRONMENTS[normalizedName];
+}
+
+/**
+ * 解析环境名称为标准 Loki 环境 key
+ * @param {string} env - 环境参数
+ * @returns {string|null} 标准环境 key，如 'cms'
+ */
+export function resolveLokiEnvName(env) {
+  if (!env) return null;
+  return LOKI_ENV_ALIASES[env.toLowerCase()] || env.toLowerCase();
 }

package/index.js

@@ -4,16 +4,18 @@
  * Log Query MCP Server
  *
  * 提供以下工具：
- * - query_log: 查询服务日志
- * - search_log: 搜索日志关键词
+ * - query_log: 查询服务日志（支持测试环境 SSH + 生产环境 Loki）
+ * - search_log: 搜索日志关键词（生产环境自动提取 traceId）
  * - list_services: 列出可用服务
  * - test_connection: 测试 SSH 连接
  * - list_pods: 列出 pods 及状态
  * - describe_pod: 获取 pod 详情
  * - get_pod_logs: 获取 pod 日志
  * - get_events: 获取 namespace 事件
- * - trace_log: 根据 traceId 跨服务查询日志
+ * - trace_log: 根据 traceId 跨服务查询日志（生产环境一次查询所有服务）
  * - detect_context: 根据工作目录自动检测 namespace 和服务
+ * - list_loki_environments: 列出可用的 Loki 生产环境
+ * - list_loki_services: 列出 Loki 环境下的服务
  */
 
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
@@ -24,13 +26,19 @@ import {
 } from '@modelcontextprotocol/sdk/types.js';
 
 import { queryLog, testConnection, executeKubectl } from './ssh-client.js';
-import { findService, getAllServices, DEFAULTS, DEFAULT_NAMESPACE, SERVICES, NAMESPACES, detectContextFromPath } from './config.js';
+import { findService, getAllServices, DEFAULTS, DEFAULT_NAMESPACE, SERVICES, NAMESPACES, detectContextFromPath, isLokiEnv, resolveLokiEnvName, LOKI_ENVIRONMENTS } from './config.js';
+import {
+  queryLoki, queryLokiAutoRange, parseTimeStr,
+  extractTraceIds, parseServiceFromFilename, groupLogsByService,
+  buildServiceLogQL, buildProjectLogQL, getLokiServiceDirName,
+  listLokiEnvironments as getLokiEnvList, listLokiServices as getLokiSvcList
+} from './loki-client.js';
 
 // 创建 MCP Server
 const server = new Server(
   {
     name: 'mcp-log-query',
-    version: '2.0.0',
+    version: '3.0.0',
   },
   {
     capabilities: {
@@ -45,7 +53,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
     tools: [
       {
         name: 'query_log',
-        description: '查询服务容器的日志文件。返回最近的日志内容。',
+        description: '查询服务容器的日志文件。返回最近的日志内容。支持通过 env 参数查询生产环境日志（Loki）。',
         inputSchema: {
           type: 'object',
           properties: {
@@ -61,6 +69,18 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
               type: 'number',
               description: '返回的日志行数，默认 100',
               default: 100
+            },
+            env: {
+              type: 'string',
+              description: '环境标识，不指定则查询测试环境（走 SSH）。可选值：cms/prod/生产（CMS生产环境）、城阳/cy/chengyang、临颖/ly/linying、漯河/lh/luohe、德阳/dy/deyang（私有化环境）'
+            },
+            from: {
+              type: 'string',
+              description: '(Loki) 查询起始时间，如 "2026-02-05 10:00:00"。指定后禁用自动递进'
+            },
+            to: {
+              type: 'string',
+              description: '(Loki) 查询结束时间，如 "2026-02-06 12:00:00"。不指定则为当前时间'
             }
           },
           required: ['service']
@@ -68,7 +88,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
       },
       {
         name: 'search_log',
-        description: '在服务日志中搜索关键词。支持正则表达式。',
+        description: '在服务日志中搜索关键词。支持正则表达式。生产环境会自动提取 traceId 列表。',
         inputSchema: {
           type: 'object',
           properties: {
@@ -93,6 +113,18 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
               type: 'boolean',
               description: '是否区分大小写，默认 false',
               default: false
+            },
+            env: {
+              type: 'string',
+              description: '环境标识，不指定则查询测试环境（走 SSH）。可选值：cms/prod/生产（CMS生产环境）、城阳/cy/chengyang、临颖/ly/linying、漯河/lh/luohe、德阳/dy/deyang（私有化环境）'
+            },
+            from: {
+              type: 'string',
+              description: '(Loki) 查询起始时间，如 "2026-02-05 10:00:00"。指定后禁用自动递进'
+            },
+            to: {
+              type: 'string',
+              description: '(Loki) 查询结束时间，如 "2026-02-06 12:00:00"。不指定则为当前时间'
             }
           },
           required: ['service', 'keyword']
@@ -201,7 +233,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
       },
       {
         name: 'trace_log',
-        description: '根据 traceId 跨服务查询日志，用于追踪完整调用链',
+        description: '根据 traceId 跨服务查询日志，用于追踪完整调用链。生产环境使用 Loki API 一次查询所有服务。',
         inputSchema: {
           type: 'object',
           properties: {
@@ -222,6 +254,18 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
               type: 'number',
               description: '显示匹配行前后的上下文行数，默认 3',
               default: 3
+            },
+            env: {
+              type: 'string',
+              description: '环境标识，不指定则查询测试环境（走 SSH）。可选值：cms/prod/生产（CMS生产环境）、城阳/cy/chengyang、临颖/ly/linying、漯河/lh/luohe、德阳/dy/deyang（私有化环境）'
+            },
+            from: {
+              type: 'string',
+              description: '(Loki) 查询起始时间，如 "2026-02-05 10:00:00"。指定后禁用自动递进'
+            },
+            to: {
+              type: 'string',
+              description: '(Loki) 查询结束时间，如 "2026-02-06 12:00:00"。不指定则为当前时间'
             }
           },
           required: ['traceId']
@@ -241,6 +285,34 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
           },
           required: ['workspace_path']
         }
+      },
+      // ========== Loki 生产环境工具 ==========
+      {
+        name: 'list_loki_environments',
+        description: '列出所有可用的 Loki 生产环境',
+        inputSchema: {
+          type: 'object',
+          properties: {}
+        }
+      },
+      {
+        name: 'list_loki_services',
+        description: '列出指定 Loki 环境下的所有可用服务',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            env: {
+              type: 'string',
+              description: '环境标识。可选值：cms/prod/生产（CMS生产环境）、城阳/cy/chengyang、临颖/ly/linying、漯河/lh/luohe、德阳/dy/deyang（私有化环境）',
+              default: 'cms'
+            },
+            project: {
+              type: 'string',
+              description: '项目名，默认 senior',
+              default: 'senior'
+            }
+          }
+        }
       }
     ]
   };
@@ -252,15 +324,43 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
   try {
     switch (name) {
       case 'query_log': {
-        // 支持传入 namespace 参数覆盖默认值
+        // 判断是否走 Loki（生产环境）
+        if (isLokiEnv(args.env)) {
+          const envKey = resolveLokiEnvName(args.env);
+          const envConfig = LOKI_ENVIRONMENTS[envKey];
+          const project = envConfig.defaultProject || 'senior';
+          const serviceDirName = getLokiServiceDirName(args.service);
+          const maxLines = args.lines || DEFAULTS.lines;
+
+          const expr = buildServiceLogQL(project, serviceDirName, '', envKey);
+          console.error(`[MCP] Loki 查询日志: env=${envKey}, service=${args.service}, expr=${expr}`);
+
+          // 构建时间范围选项
+          const timeOpts = { maxLines };
+          if (args.from) timeOpts.from = parseTimeStr(args.from);
+          if (args.to) timeOpts.to = parseTimeStr(args.to);
+
+          const lokiResult = await queryLokiAutoRange(envKey, expr, timeOpts);
+
+          if (lokiResult.logs.length === 0) {
+            const errorHint = lokiResult.error ? `\n\n⚠️ **${lokiResult.error}**` : '';
+            return { content: [{ type: 'text', text: `## ${args.service} 日志 (${envKey} 生产环境)\n\n⚠️ 已自动搜索 5分钟 → 30分钟 → 1小时 → 3小时 → 24小时 范围，均未找到日志。${errorHint}\n\n请确认：\n1. 服务名是否正确\n2. 如需查询更早的日志，请使用 \`from\`/\`to\` 参数指定具体时间范围` }] };
+          }
+
+          let text = `## ${args.service} 日志 (${envKey} 生产环境, ${lokiResult.timeRange.label}内, ${lokiResult.logs.length} 行)\n\n`;
+          text += `\`\`\`\n${lokiResult.logs.join('\n')}\n\`\`\``;
+          if (lokiResult.traceIds.length > 0) {
+            text += `\n\n🔑 **提取到的 traceId** (${lokiResult.traceIds.length} 个):\n`;
+            lokiResult.traceIds.slice(0, 20).forEach((id, i) => { text += `  ${i + 1}. \`${id}\`\n`; });
+            if (lokiResult.traceIds.length > 20) text += `  ... 还有 ${lokiResult.traceIds.length - 20} 个\n`;
+          }
+          return { content: [{ type: 'text', text }] };
+        }
+
+        // 测试环境：走 SSH
         const service = findService(args.service, args.namespace);
         if (!service) {
-          return {
-            content: [{
-              type: 'text',
-              text: `错误: 未找到服务 "${args.service}"。使用 list_services 查看可用服务。`
-            }]
-          };
+          return { content: [{ type: 'text', text: `错误: 未找到服务 "${args.service}"。使用 list_services 查看可用服务。` }] };
         }
 
         const lines = args.lines || DEFAULTS.lines;
@@ -278,15 +378,47 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       }
 
       case 'search_log': {
-        // 支持传入 namespace 参数覆盖默认值
+        // 判断是否走 Loki（生产环境）
+        if (isLokiEnv(args.env)) {
+          const envKey = resolveLokiEnvName(args.env);
+          const envConfig = LOKI_ENVIRONMENTS[envKey];
+          const project = envConfig.defaultProject || 'senior';
+          const serviceDirName = getLokiServiceDirName(args.service);
+          const keyword = args.keyword;
+
+          const expr = buildServiceLogQL(project, serviceDirName, keyword, envKey);
+          console.error(`[MCP] Loki 搜索日志: env=${envKey}, service=${args.service}, keyword=${keyword}`);
+
+          // 构建时间范围选项
+          const timeOpts = { maxLines: 200 };
+          if (args.from) timeOpts.from = parseTimeStr(args.from);
+          if (args.to) timeOpts.to = parseTimeStr(args.to);
+
+          const lokiResult = await queryLokiAutoRange(envKey, expr, timeOpts);
+
+          if (lokiResult.logs.length === 0) {
+            const errorHint = lokiResult.error ? `\n\n⚠️ **${lokiResult.error}**` : '';
+            return { content: [{ type: 'text', text: `## ${args.service} 日志搜索结果 (${envKey} 生产环境)\n\n**关键词**: ${keyword}\n\n⚠️ 已自动搜索 5分钟 → 30分钟 → 1小时 → 3小时 → 24小时 范围，均未找到匹配内容。${errorHint}\n\n请确认：\n1. 关键词是否正确\n2. 服务名是否正确\n3. 如需查询更早的日志，请使用 \`from\`/\`to\` 参数指定具体时间范围` }] };
+          }
+
+          let text = `## ${args.service} 日志搜索结果 (${envKey} 生产环境, ${lokiResult.timeRange.label}内)\n\n`;
+          text += `**关键词**: ${keyword}\n**匹配行数**: ${lokiResult.logs.length}\n**时间范围**: ${lokiResult.timeRange.label}\n\n`;
+          text += `\`\`\`\n${lokiResult.logs.join('\n')}\n\`\`\``;
+
+          // 自动提取 traceId（核心功能：帮助用户获取 traceId 进行链路追踪）
+          if (lokiResult.traceIds.length > 0) {
+            text += `\n\n🔑 **提取到的 traceId** (${lokiResult.traceIds.length} 个):\n`;
+            lokiResult.traceIds.slice(0, 20).forEach((id, i) => { text += `  ${i + 1}. \`${id}\`\n`; });
+            if (lokiResult.traceIds.length > 20) text += `  ... 还有 ${lokiResult.traceIds.length - 20} 个\n`;
+            text += `\n💡 **提示**: 可以使用 \`trace_log(traceId: "xxx", env: "${args.env}")\` 查看完整调用链`;
+          }
+          return { content: [{ type: 'text', text }] };
+        }
+
+        // 测试环境：走 SSH
         const service = findService(args.service, args.namespace);
         if (!service) {
-          return {
-            content: [{
-              type: 'text',
-              text: `错误: 未找到服务 "${args.service}"。使用 list_services 查看可用服务。`
-            }]
-          };
+          return { content: [{ type: 'text', text: `错误: 未找到服务 "${args.service}"。使用 list_services 查看可用服务。` }] };
         }
 
         const keyword = args.keyword;
@@ -416,14 +548,72 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       case 'trace_log': {
         const traceId = args.traceId;
         const contextLines = args.context_lines || 3;
-        const targetNamespace = args.namespace || null;  // 支持指定 namespace
+
+        // 判断是否走 Loki（生产环境）- 一次 API 调用搜索所有服务
+        if (isLokiEnv(args.env)) {
+          const envKey = resolveLokiEnvName(args.env);
+          const envConfig = LOKI_ENVIRONMENTS[envKey];
+          const project = envConfig.defaultProject || 'senior';
+
+          // 构建时间范围选项
+          const timeOpts = {};
+          if (args.from) timeOpts.from = parseTimeStr(args.from);
+          if (args.to) timeOpts.to = parseTimeStr(args.to);
+
+          // 如果指定了服务列表，按服务查询；否则按项目查询（一次搜索所有服务）
+          let lokiResult;
+          const targetServices = args.services || [];
+
+          if (targetServices.length > 0) {
+            // 指定服务：逐个查询
+            const allLogs = [];
+            const allLabels = [];
+            for (const svc of targetServices) {
+              const dirName = getLokiServiceDirName(svc);
+              const expr = buildServiceLogQL(project, dirName, traceId, envKey);
+              console.error(`[MCP] Loki trace: env=${envKey}, service=${svc}, traceId=${traceId}`);
+              const r = await queryLokiAutoRange(envKey, expr, { ...timeOpts, maxLines: 500 });
+              allLogs.push(...r.logs);
+              allLabels.push(...r.labels);
+            }
+            lokiResult = { logs: allLogs, labels: allLabels, traceIds: extractTraceIds(allLogs), timeRange: { label: '自动递进' } };
+          } else {
+            // 未指定服务：按项目一次查询所有服务（高效！）
+            const expr = buildProjectLogQL(project, traceId, envKey);
+            console.error(`[MCP] Loki trace (全项目): env=${envKey}, project=${project}, traceId=${traceId}`);
+            lokiResult = await queryLokiAutoRange(envKey, expr, { ...timeOpts, maxLines: 1000 });
+          }
+
+          if (lokiResult.logs.length === 0) {
+            const errorHint = lokiResult.error ? `\n\n⚠️ **${lokiResult.error}**` : '';
+            return { content: [{ type: 'text', text: `## TraceId 追踪结果 (${envKey} 生产环境)\n\n**traceId**: \`${traceId}\`\n\n❌ 已自动搜索 5分钟 → 30分钟 → 1小时 → 3小时 → 24小时 范围，均未找到匹配日志。${errorHint}\n\n请确认：\n1. traceId 是否正确\n2. 如需查询更早的日志，请使用 \`from\`/\`to\` 参数指定具体时间范围` }] };
+          }
+
+          // 按服务分组展示
+          const groups = groupLogsByService(lokiResult);
+          const serviceNames = Object.keys(groups).sort();
+
+          let text = `## TraceId 追踪结果 (${envKey} 生产环境, ${lokiResult.timeRange.label}内)\n\n`;
+          text += `**traceId**: \`${traceId}\`\n`;
+          text += `**匹配服务数**: ${serviceNames.length}\n`;
+          text += `**总日志行数**: ${lokiResult.logs.length}\n\n`;
+
+          for (const svcName of serviceNames) {
+            const group = groups[svcName];
+            text += `### ${svcName}\n`;
+            text += `\`\`\`\n${group.logs.join('\n')}\n\`\`\`\n\n`;
+          }
+
+          return { content: [{ type: 'text', text }] };
+        }
+
+        // 测试环境：走 SSH（逐个服务搜索）
+        const targetNamespace = args.namespace || null;
         let servicesToSearch = args.services || [];
 
-        // 如果没有指定服务，搜索所有服务
         if (servicesToSearch.length === 0) {
           servicesToSearch = Object.keys(SERVICES);
         } else {
-          // 解析服务别名
           servicesToSearch = servicesToSearch.map(s => {
             const service = findService(s, targetNamespace);
             return service ? service.name : s;
@@ -434,7 +624,6 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 
         const results = [];
         for (const serviceName of servicesToSearch) {
-          // 使用 findService 获取服务配置，支持 namespace 覆盖
           const service = findService(serviceName, targetNamespace);
           if (!service) continue;
 
@@ -443,30 +632,18 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             const result = await queryLog(service, command);
 
             if (result && result.trim() && !result.includes('未找到')) {
-              results.push({
-                service: serviceName,
-                namespace: service.namespace,
-                logs: result
-              });
+              results.push({ service: serviceName, namespace: service.namespace, logs: result });
             }
           } catch (err) {
-            // 忽略单个服务的错误，继续搜索其他服务
             console.error(`[MCP] 搜索 ${serviceName} 失败: ${err.message}`);
           }
         }
 
         if (results.length === 0) {
-          return {
-            content: [{
-              type: 'text',
-              text: `## TraceId 追踪结果\n\n**traceId**: ${traceId}\n**namespace**: ${targetNamespace || '默认'}\n\n❌ 未在任何服务中找到匹配的日志`
-            }]
-          };
+          return { content: [{ type: 'text', text: `## TraceId 追踪结果\n\n**traceId**: ${traceId}\n**namespace**: ${targetNamespace || '默认'}\n\n❌ 未在任何服务中找到匹配的日志` }] };
         }
 
-        const output = results.map(r =>
-          `### ${r.service} (${r.namespace})\n\`\`\`\n${r.logs}\n\`\`\``
-        ).join('\n\n');
+        const output = results.map(r => `### ${r.service} (${r.namespace})\n\`\`\`\n${r.logs}\n\`\`\``).join('\n\n');
 
         return {
           content: [{
@@ -522,6 +699,39 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         };
       }
 
+      // ========== Loki 生产环境工具处理 ==========
+      case 'list_loki_environments': {
+        const envs = getLokiEnvList();
+        if (envs.length === 0) {
+          return { content: [{ type: 'text', text: '## Loki 环境列表\n\n⚠️ 未配置任何 Loki 环境' }] };
+        }
+
+        const list = envs.map(e =>
+          `- **${e.name}**: ${e.description}\n  Grafana: ${e.grafanaUrl}\n  默认项目: ${e.project}`
+        ).join('\n');
+
+        return { content: [{ type: 'text', text: `## Loki 生产环境列表\n\n${list}` }] };
+      }
+
+      case 'list_loki_services': {
+        const envKey = resolveLokiEnvName(args.env || 'cms');
+        const project = args.project || 'senior';
+
+        if (!envKey || !LOKI_ENVIRONMENTS[envKey]) {
+          return { content: [{ type: 'text', text: `错误: 未知环境 "${args.env}"。使用 list_loki_environments 查看可用环境。` }] };
+        }
+
+        console.error(`[MCP] 列出 Loki 服务: env=${envKey}, project=${project}`);
+        const services = await getLokiSvcList(envKey, project);
+
+        if (services.length === 0) {
+          return { content: [{ type: 'text', text: `## Loki 服务列表 (${envKey})\n\n⚠️ 未找到任何服务` }] };
+        }
+
+        const list = services.map((s, i) => `  ${i + 1}. ${s}`).join('\n');
+        return { content: [{ type: 'text', text: `## Loki 服务列表 (${envKey}, project=${project})\n\n共 ${services.length} 个服务:\n${list}` }] };
+      }
+
       default:
         return {
           content: [{
@@ -546,7 +756,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 async function main() {
   const transport = new StdioServerTransport();
   await server.connect(transport);
-  console.error('[MCP] Log Query Server v2.0 已启动');
+  console.error('[MCP] Log Query Server v3.0 已启动 (支持 Loki 生产环境日志)');
 }
 
 main().catch((error) => {

package/loki-client.js

@@ -0,0 +1,464 @@
+/**
+ * Grafana Loki API 客户端
+ *
+ * 通过 Grafana 代理接口查询 Loki 日志，支持：
+ * - 日志查询（LogQL）
+ * - 标签/标签值获取
+ * - traceId 自动提取
+ * - 服务名自动识别（从 filename 标签解析）
+ * - 时间范围自动递进（1h → 24h → 72h → 7d）
+ */
+
+import { LOKI_ENVIRONMENTS, LOKI_DEFAULTS } from './config.js';
+
+// 时间范围自动递进策略（毫秒）
+const AUTO_RANGE_STEPS = [
+  { range: 5 * 60 * 1000,            label: '5 分钟' },
+  { range: 30 * 60 * 1000,           label: '30 分钟' },
+  { range: 1 * 60 * 60 * 1000,       label: '1 小时' },
+  { range: 3 * 60 * 60 * 1000,       label: '3 小时' },
+  { range: 24 * 60 * 60 * 1000,      label: '24 小时' },
+];
+
+// ============================================================
+// 核心查询
+// ============================================================
+
+/**
+ * 执行 Loki 日志查询
+ * @param {string} envName - 环境名称，如 'cms'
+ * @param {string} expr - LogQL 表达式
+ * @param {Object} options - 查询选项
+ * @param {number} options.from - 起始时间（毫秒时间戳），默认 1 小时前
+ * @param {number} options.to - 结束时间（毫秒时间戳），默认当前
+ * @param {number} options.maxLines - 最大返回行数，默认 100
+ * @param {string} options.direction - 排序方向 'backward'|'forward'，默认 'backward'
+ * @returns {Object} { logs: string[], labels: Object[], traceIds: string[], stats: Object }
+ */
+export async function queryLoki(envName, expr, options = {}) {
+  const env = getLokiEnv(envName);
+  const now = Date.now();
+  const from = options.from || (now - LOKI_DEFAULTS.defaultTimeRange);
+  const to = options.to || now;
+  const maxLines = options.maxLines || LOKI_DEFAULTS.maxLines;
+  const direction = options.direction || 'backward';
+
+  const url = `${env.grafanaUrl}/api/ds/query?ds_type=loki`;
+  const body = {
+    queries: [{
+      refId: 'A',
+      expr,
+      queryType: 'range',
+      datasource: { type: 'loki', uid: env.datasourceUid },
+      editorMode: 'builder',
+      direction,
+      maxLines,
+      datasourceId: env.datasourceId,
+      intervalMs: 1000,
+      maxDataPoints: 1000
+    }],
+    from: String(from),
+    to: String(to)
+  };
+
+  console.error(`[Loki] 查询: env=${envName}, expr=${expr}`);
+
+  const resp = await fetch(url, {
+    method: 'POST',
+    headers: buildHeaders(env),
+    body: JSON.stringify(body)
+  });
+
+  if (!resp.ok) {
+    const text = await resp.text();
+    throw new Error(`Loki 查询失败 (${resp.status}): ${text}`);
+  }
+
+  const data = await resp.json();
+  return parseLokiResponse(data);
+}
+
+/**
+ * 带时间范围自动递进的 Loki 查询
+ *
+ * 策略：1h → 24h → 72h → 7d，找到结果立即返回
+ * 如果用户指定了 from/to，则直接使用指定范围，不递进
+ *
+ * @param {string} envName - 环境名称
+ * @param {string} expr - LogQL 表达式
+ * @param {Object} options - 查询选项
+ * @param {number} options.from - 起始时间戳（毫秒），指定后不递进
+ * @param {number} options.to - 结束时间戳（毫秒），指定后不递进
+ * @param {number} options.maxLines - 最大返回行数
+ * @param {string} options.direction - 排序方向
+ * @returns {Object} { logs, labels, traceIds, stats, timeRange: { label, from, to } }
+ */
+export async function queryLokiAutoRange(envName, expr, options = {}) {
+  // 如果用户明确指定了 from/to，直接查询不递进
+  if (options.from && options.to) {
+    console.error(`[Loki] 使用指定时间范围查询: ${new Date(options.from).toLocaleString()} ~ ${new Date(options.to).toLocaleString()}`);
+    try {
+      const result = await queryLoki(envName, expr, options);
+      result.timeRange = { label: '自定义', from: options.from, to: options.to };
+      return result;
+    } catch (e) {
+      const isTimeout = e.message.includes('timeout') || e.message.includes('504') || e.message.includes('Timeout');
+      console.error(`[Loki] ❌ 指定时间范围查询${isTimeout ? '超时' : '失败'}: ${e.message.substring(0, 200)}`);
+      return {
+        logs: [], labels: [], traceIds: [], stats: null,
+        timeRange: { label: '自定义', from: options.from, to: options.to },
+        notFound: true,
+        error: isTimeout
+          ? '查询超时（数据量过大），请缩小时间范围或指定具体服务'
+          : `查询失败: ${e.message.substring(0, 200)}`
+      };
+    }
+  }
+
+  // 自动递进：从小范围到大范围
+  const now = Date.now();
+  for (const step of AUTO_RANGE_STEPS) {
+    const from = now - step.range;
+    const to = now;
+
+    console.error(`[Loki] 自动递进: 尝试 ${step.label} 范围...`);
+
+    try {
+      const result = await queryLoki(envName, expr, { ...options, from, to });
+
+      if (result.logs.length > 0) {
+        console.error(`[Loki] ✅ 在 ${step.label} 范围内找到 ${result.logs.length} 行日志`);
+        result.timeRange = { label: step.label, from, to };
+        return result;
+      }
+
+      console.error(`[Loki] ⏭️ ${step.label} 范围内无结果，扩大范围...`);
+    } catch (e) {
+      // 查询超时或失败，停止递进，返回优雅降级结果
+      const isTimeout = e.message.includes('timeout') || e.message.includes('504') || e.message.includes('Timeout');
+      console.error(`[Loki] ⚠️ ${step.label} 范围查询${isTimeout ? '超时' : '失败'}: ${e.message.substring(0, 200)}`);
+      return {
+        logs: [], labels: [], traceIds: [], stats: null,
+        timeRange: { label: step.label, from, to },
+        notFound: true,
+        error: isTimeout
+          ? `查询在递进到 ${step.label} 范围时超时（数据量过大），请缩小时间范围或指定具体服务查询`
+          : `查询在递进到 ${step.label} 范围时失败: ${e.message.substring(0, 200)}`
+      };
+    }
+  }
+
+  // 所有范围都没找到
+  console.error(`[Loki] ❌ 所有时间范围均未找到结果`);
+  return {
+    logs: [],
+    labels: [],
+    traceIds: [],
+    stats: null,
+    timeRange: { label: '未找到', from: null, to: null },
+    notFound: true
+  };
+}
+
+/**
+ * 解析用户传入的时间字符串为毫秒时间戳
+ * 支持格式: "2026-02-06 12:00:00", "2026-02-06", ISO 8601 等
+ * @param {string} timeStr - 时间字符串
+ * @returns {number|null} 毫秒时间戳，解析失败返回 null
+ */
+export function parseTimeStr(timeStr) {
+  if (!timeStr) return null;
+  // 如果是纯数字，当作时间戳
+  if (/^\d{10,13}$/.test(timeStr)) {
+    const ts = parseInt(timeStr);
+    return ts < 1e12 ? ts * 1000 : ts; // 秒 → 毫秒
+  }
+  const d = new Date(timeStr);
+  return isNaN(d.getTime()) ? null : d.getTime();
+}
+
+// ============================================================
+// 标签查询
+// ============================================================
+
+/** 获取 Loki 标签列表 */
+export async function getLokiLabels(envName) {
+  const env = getLokiEnv(envName);
+  const now = Date.now();
+  const start = (now - LOKI_DEFAULTS.defaultTimeRange) * 1_000_000;
+  const end = now * 1_000_000;
+  const url = `${env.grafanaUrl}/api/datasources/uid/${env.datasourceUid}/resources/labels?start=${start}&end=${end}`;
+  const resp = await fetch(url, { headers: buildHeaders(env) });
+  if (!resp.ok) throw new Error(`获取标签失败 (${resp.status})`);
+  const data = await resp.json();
+  return data.data || [];
+}
+
+/** 获取 Loki 标签值 */
+export async function getLokiLabelValues(envName, label, query = '') {
+  const env = getLokiEnv(envName);
+  const now = Date.now();
+  const start = (now - LOKI_DEFAULTS.defaultTimeRange) * 1_000_000;
+  const end = now * 1_000_000;
+  let url = `${env.grafanaUrl}/api/datasources/uid/${env.datasourceUid}/resources/label/${label}/values?start=${start}&end=${end}`;
+  if (query) url += `&query=${encodeURIComponent(query)}`;
+  const resp = await fetch(url, { headers: buildHeaders(env) });
+  if (!resp.ok) throw new Error(`获取标签值失败 (${resp.status})`);
+  const data = await resp.json();
+  return data.data || [];
+}
+
+// ============================================================
+// 响应解析
+// ============================================================
+
+/** 解析 Grafana Loki 查询响应 */
+export function parseLokiResponse(data) {
+  const result = { logs: [], labels: [], traceIds: [], stats: null };
+  const frames = data?.results?.A?.frames;
+  if (!frames || frames.length === 0) return result;
+
+  for (const frame of frames) {
+    const values = frame?.data?.values;
+    if (!values || values.length < 3) continue;
+    // values[0]: 标签数组, values[1]: 时间戳数组, values[2]: 日志行数组
+    const labelsArr = values[0] || [];
+    const linesArr = values[2] || [];
+    for (let i = 0; i < linesArr.length; i++) {
+      result.logs.push(linesArr[i]);
+      result.labels.push(labelsArr[i] || {});
+    }
+  }
+
+  result.traceIds = extractTraceIds(result.logs);
+
+  const stats = frames[0]?.schema?.meta?.stats;
+  if (stats) {
+    result.stats = {};
+    for (const s of stats) { result.stats[s.displayName] = s.value; }
+  }
+  return result;
+}
+
+// ============================================================
+// traceId 提取
+// ============================================================
+
+/**
+ * 从日志行中提取 traceId（32位十六进制，在方括号中）
+ * 日志格式: [clife-senior] 时间 级别 [服务] [pod] [线程] [OT-spanId] [traceId] 类名 - 内容
+ */
+export function extractTraceIds(lines) {
+  const traceIdSet = new Set();
+
+  const regex = /\[([a-f0-9]{32})\]/gi;
+  for (const line of lines) {
+    let match;
+    while ((match = regex.exec(line)) !== null) {
+      traceIdSet.add(match[1].toLowerCase());
+    }
+    regex.lastIndex = 0;
+  }
+  return [...traceIdSet];
+}
+
+// ============================================================
+// 服务名解析
+// ============================================================
+
+/**
+ * 从 Loki filename 标签中解析服务名
+ * filename 格式: /data/services/logs/senior/clife-senior-health-app/normal_logs/normal.log
+ * 解析结果: clife-senior-health
+ */
+export function parseServiceFromFilename(filename) {
+  if (!filename) return null;
+  // 匹配 /{service-name}-app/ 或 /{service-name}-service/ 模式
+  const match = filename.match(/\/(clife-senior-[a-zA-Z0-9-]+?)(?:-app|-service)\//);
+  if (match) return match[1];
+  // 兜底：匹配非 clife-senior 前缀的服务（如 device-manage-service）
+  const match2 = filename.match(/\/([a-zA-Z0-9-]+?)(?:-app|-service)\//);
+  if (match2) return match2[1];
+  return null;
+}
+
+/**
+ * 将查询结果按服务分组
+ * @param {Object} lokiResult - parseLokiResponse 的返回值
+ * @returns {Object} { serviceName: { logs: string[], traceIds: string[] } }
+ */
+export function groupLogsByService(lokiResult) {
+  const groups = {};
+
+  for (let i = 0; i < lokiResult.logs.length; i++) {
+    const label = lokiResult.labels[i] || {};
+    const serviceName = parseServiceFromFilename(label.filename) || 'unknown';
+    const logLine = lokiResult.logs[i];
+
+    if (!groups[serviceName]) {
+      groups[serviceName] = { logs: [], traceIds: new Set() };
+    }
+    groups[serviceName].logs.push(logLine);
+
+    // 从该行提取 traceId
+    const ids = extractTraceIds([logLine]);
+    ids.forEach(id => groups[serviceName].traceIds.add(id));
+  }
+
+  // Set → Array
+  for (const key of Object.keys(groups)) {
+    groups[key].traceIds = [...groups[key].traceIds];
+  }
+
+  return groups;
+}
+
+// ============================================================
+// LogQL 构建辅助
+// ============================================================
+
+/**
+ * 构建按服务查询的 LogQL 表达式
+ * 根据环境是否有 project 标签，自动选择不同的 filename 路径格式：
+ *   - 有 project 标签（CMS）: /data/services/logs/senior/clife-senior-health-app/normal_logs/normal.log
+ *   - 无 project 标签（私有化）: /data/services/logs/clife-senior-health-app/normal_logs/normal.log
+ *
+ * @param {string} project - 项目名，如 'senior'
+ * @param {string} servicePodPattern - 服务目录名，如 'clife-senior-health-app'
+ * @param {string} keyword - 搜索关键词（可选）
+ * @param {string} envName - 环境名称，如 'cms'、'chengyang'
+ */
+export function buildServiceLogQL(project, servicePodPattern, keyword = '', envName = '') {
+  const env = envName ? LOKI_ENVIRONMENTS[envName] : null;
+  const hasProject = env ? env.hasProjectLabel !== false : true;
+
+  // CMS: /data/services/logs/senior/xxx-app/...  私有化: /data/services/logs/xxx-app/...
+  const filename = hasProject
+    ? `/data/services/logs/${project}/${servicePodPattern}/normal_logs/normal.log`
+    : `/data/services/logs/${servicePodPattern}/normal_logs/normal.log`;
+
+  let expr = `{filename="${filename}"}`;
+  if (keyword) {
+    expr += ` |= \`${keyword}\``;
+  }
+  return expr;
+}
+
+/**
+ * 构建按项目查询的 LogQL 表达式（搜索整个项目所有服务）
+ * 根据环境是否有 project 标签，自动选择不同的查询方式：
+ *   - 有 project 标签（CMS）: {project="senior"} |= `keyword`
+ *   - 无 project 标签（私有化）: {filename=~"/data/services/logs/clife-senior-.*normal.log"} |= `keyword`
+ *
+ * @param {string} project - 项目名，如 'senior'
+ * @param {string} keyword - 搜索关键词
+ * @param {string} envName - 环境名称，如 'cms'、'chengyang'
+ */
+export function buildProjectLogQL(project, keyword, envName = '') {
+  const env = envName ? LOKI_ENVIRONMENTS[envName] : null;
+  const hasProject = env ? env.hasProjectLabel !== false : true;
+
+  if (hasProject) {
+    // CMS: 直接用 project 标签，高效精确
+    return `{project="${project}"} |= \`${keyword}\``;
+  } else {
+    // 私有化: 用 filename 正则匹配所有 clife-{project}-* 服务的 normal.log
+    return `{filename=~"/data/services/logs/clife-${project}-.*normal.log"} |= \`${keyword}\``;
+  }
+}
+
+// ============================================================
+// 内部辅助函数
+// ============================================================
+
+/** 获取 Loki 环境配置 */
+function getLokiEnv(envName) {
+  const env = LOKI_ENVIRONMENTS[envName];
+  if (!env) {
+    const available = Object.keys(LOKI_ENVIRONMENTS).join(', ');
+    throw new Error(`未知的 Loki 环境 "${envName}"，可用环境: ${available}`);
+  }
+  return env;
+}
+
+/** 构建请求头 */
+function buildHeaders(env) {
+  const headers = {
+    'Content-Type': 'application/json',
+    'Accept': 'application/json',
+    'x-grafana-org-id': String(env.orgId || 1),
+    'x-plugin-id': 'loki',
+    'x-datasource-uid': env.datasourceUid
+  };
+
+  // 如果配置了认证信息，添加 Basic Auth
+  if (env.username && env.password) {
+    const auth = Buffer.from(`${env.username}:${env.password}`).toString('base64');
+    headers['Authorization'] = `Basic ${auth}`;
+  }
+
+  return headers;
+}
+
+// ============================================================
+// 公共辅助函数
+// ============================================================
+
+/** 获取所有可用的 Loki 环境列表 */
+export function listLokiEnvironments() {
+  return Object.entries(LOKI_ENVIRONMENTS).map(([key, env]) => ({
+    name: key,
+    description: env.description,
+    grafanaUrl: env.grafanaUrl,
+    project: env.defaultProject
+  }));
+}
+
+/**
+ * 获取指定环境下的服务列表（从 Loki filename 标签动态获取）
+ * 根据环境是否有 project 标签，使用不同的查询方式：
+ *   - 有 project 标签（CMS）: 用 {project="senior"} 过滤
+ *   - 无 project 标签（私有化）: 获取全部 filename 后按 clife-{project}- 前缀过滤
+ *
+ * @param {string} envName - 环境名称
+ * @param {string} project - 项目名，如 'senior'
+ * @returns {string[]} 服务名列表
+ */
+export async function listLokiServices(envName, project = 'senior') {
+  const env = LOKI_ENVIRONMENTS[envName];
+  const hasProject = env ? env.hasProjectLabel !== false : true;
+
+  let filenames;
+  if (hasProject) {
+    // CMS: 直接用 project 标签过滤
+    filenames = await getLokiLabelValues(envName, 'filename', `{project="${project}"}`);
+  } else {
+    // 私有化: 获取全部 filename，然后按 clife-{project}- 前缀过滤
+    filenames = await getLokiLabelValues(envName, 'filename');
+    filenames = filenames.filter(f => f.includes(`/clife-${project}-`));
+  }
+
+  const serviceSet = new Set();
+  for (const f of filenames) {
+    if (!f.includes('/normal_logs/normal.log')) continue;
+    const svc = parseServiceFromFilename(f);
+    if (svc) serviceSet.add(svc);
+  }
+
+  return [...serviceSet].sort();
+}
+
+/**
+ * 根据服务简称获取 Loki 中的服务目录名
+ * 例如: 'health' → 'clife-senior-health-app'
+ * @param {string} serviceName - 服务简称，如 'health', 'core', 'gateway'
+ * @returns {string} 服务目录名
+ */
+export function getLokiServiceDirName(serviceName) {
+  // 如果已经是完整名称，直接返回
+  if (serviceName.startsWith('clife-senior-')) {
+    return serviceName.endsWith('-app') ? serviceName : `${serviceName}-app`;
+  }
+  // 简称转完整名称
+  return `clife-senior-${serviceName}-app`;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mcp-log-query-server",
-  "version": "1.0.0",
-  "description": "MCP Server for querying server logs via SSH jump host",
+  "version": "2.1.1",
+  "description": "MCP Server for querying server logs via SSH jump host and Grafana Loki API",
   "main": "index.js",
   "type": "module",
   "bin": {
@@ -11,6 +11,7 @@
     "index.js",
     "config.js",
     "ssh-client.js",
+    "loki-client.js",
     "server-sse.js",
     "README.md"
   ],
@@ -39,4 +40,3 @@
   },
   "homepage": "https://github.com/huawang1258/mcp-services#readme"
 }
-