mcp-log-query-server 3.5.1 → 3.5.2

package/index.js

@@ -27,6 +27,7 @@ import {
 
 import { queryLog, testConnection, executeKubectl } from './ssh-client.js';
 import { findService, getAllServices, DEFAULTS, DEFAULT_NAMESPACE, SERVICES, NAMESPACES, detectContextFromPath, isLokiEnv, resolveLokiEnvName, LOKI_ENVIRONMENTS } from './config.js';
+import { log, getLogFilePath } from './logger.js';
 import {
   queryLoki, queryLokiAutoRange, parseTimeStr,
   extractTraceIds, parseServiceFromFilename, groupLogsByService,
@@ -47,16 +48,26 @@ function withTimeout(promise, ms, label) {
   ]);
 }
 
+// 安全序列化工具参数（截断超长值，容错循环引用）
+function safeStringify(obj, maxLen = 200) {
+  try {
+    const s = JSON.stringify(obj);
+    return s.length > maxLen ? s.slice(0, maxLen) + '...' : s;
+  } catch {
+    return '<unserializable>';
+  }
+}
+
 // 进程级安全网：只记录日志，不退出进程
 // 退出会导致 stdio 断开，整个 MCP 不可用直到 IDE 重启；单次请求错误不应拖死服务
-process.on('unhandledRejection', (err) => console.error('[unhandledRejection]', err));
-process.on('uncaughtException', (err) => console.error('[uncaughtException]', err));
+process.on('unhandledRejection', (err) => log(`[unhandledRejection] ${err && err.stack || err}`));
+process.on('uncaughtException', (err) => log(`[uncaughtException] ${err && err.stack || err}`));
 
 // 创建 MCP Server
 const server = new Server(
   {
     name: 'mcp-log-query',
-    version: '3.5.1',
+    version: '3.5.2',
   },
   {
     capabilities: {
@@ -339,11 +350,12 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
   const { name, arguments: args } = request.params;
   const startTime = Date.now();
+  log(`[Tool] → ${name} start args=${safeStringify(args)}`);
 
   // 看门狗：仅记录长时间未完成的请求，不再退出进程
   // withTimeout(REQUEST_TIMEOUT) 已经保证单次请求超时会抛错
   const watchdog = setTimeout(() => {
-    console.error(`[Watchdog] ${name} 仍在运行超过 ${WATCHDOG_WARN_TIMEOUT}ms（仅记录，不退出进程）`);
+    log(`[Watchdog] ${name} 仍在运行超过 ${WATCHDOG_WARN_TIMEOUT}ms（仅记录，不退出进程）`);
   }, WATCHDOG_WARN_TIMEOUT);
   watchdog.unref();
 
@@ -354,11 +366,11 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       name
     );
     clearTimeout(watchdog);
-    console.error(`[MCP] ${name} ${Date.now() - startTime}ms`);
+    log(`[Tool] ✓ ${name} done ${Date.now() - startTime}ms`);
     return result;
   } catch (error) {
     clearTimeout(watchdog);
-    console.error(`[Error] ${name} ${Date.now() - startTime}ms: ${error.message}`);
+    log(`[Tool] ✗ ${name} FAIL ${Date.now() - startTime}ms: ${error.message}`);
     return {
       content: [{ type: 'text', text: `## 执行错误\n\n❌ ${error.message}` }],
       isError: true
@@ -834,20 +846,22 @@ process.on('SIGTERM', gracefulShutdown);
 async function main() {
   // 对齐 auggie: 监听 stdin end/close，宿主进程断开时优雅关闭
   process.stdin.on('end', () => {
-    console.error('[MCP] stdin end, initiating graceful shutdown');
+    log('[MCP] stdin end, initiating graceful shutdown');
     gracefulShutdown();
   });
   process.stdin.on('close', () => {
-    console.error('[MCP] stdin close, initiating graceful shutdown');
+    log('[MCP] stdin close, initiating graceful shutdown');
     gracefulShutdown();
   });
 
   const transport = new StdioServerTransport();
   await server.connect(transport);
-  console.error('[MCP] Log Query Server v3.5.1 已启动 (超时保护 + SSH 并发限制 + 排队超时 + 进程不自杀 + stdin 优雅关闭)');
+  const logPath = getLogFilePath();
+  log(`[MCP] Log Query Server v3.5.2 已启动 (超时保护 + SSH 并发限制 + 排队超时 + 文件日志 + 进程不自杀)`);
+  if (logPath) log(`[MCP] 本地日志文件: ${logPath}`);
 }
 
 main().catch((error) => {
-  console.error('[MCP] 启动失败:', error);
+  log(`[MCP] 启动失败: ${error && error.stack || error}`);
   process.exit(1);
 });

package/logger.js

@@ -0,0 +1,91 @@
+/**
+ * 轻量日志模块：console.error + 本地文件追加
+ *
+ * 为什么需要文件日志？
+ * Windsurf 不会把 MCP server 的 stderr 落盘到 %APPDATA%\Windsurf\logs，
+ * 只在 Output 面板实时显示。一旦进程重启、面板关闭，信息就丢了。
+ *
+ * 用法：
+ *   import { log } from './logger.js';
+ *   log('[SSH-Sem] acquire ...');
+ *
+ * 诊断卡住时：
+ *   Get-Content $env:TEMP\mcp-log-query.log -Tail 20 -Wait   (Windows)
+ *   tail -F /tmp/mcp-log-query.log                           (Linux/Mac)
+ *
+ * 环境变量：
+ * - MCP_LOG_FILE: 自定义日志文件路径（默认 <tmpdir>/mcp-log-query.log）
+ * - MCP_LOG_MAX_BYTES: 单文件最大字节数（默认 10MB，超过则轮转到 .1）
+ * - MCP_LOG_DISABLE: 设为 '1' 则禁用文件日志（只走 stderr）
+ */
+
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+const LOG_FILE = process.env.MCP_LOG_FILE || path.join(os.tmpdir(), 'mcp-log-query.log');
+const MAX_BYTES = parseInt(process.env.MCP_LOG_MAX_BYTES || `${10 * 1024 * 1024}`, 10);
+const DISABLED = process.env.MCP_LOG_DISABLE === '1';
+
+// 懒初始化：首次写入时再检查目录
+let initialized = false;
+
+function ensureInit() {
+  if (initialized) return;
+  initialized = true;
+  if (DISABLED) return;
+  try {
+    fs.mkdirSync(path.dirname(LOG_FILE), { recursive: true });
+    // 启动时打一条 banner，方便判断是不是新进程
+    fs.appendFileSync(
+      LOG_FILE,
+      `\n========== [${new Date().toISOString()}] MCP log-query 进程启动 pid=${process.pid} ==========\n`
+    );
+  } catch (err) {
+    console.error('[logger] 初始化文件日志失败，仅使用 stderr:', err.message);
+  }
+}
+
+function rotateIfNeeded() {
+  try {
+    const st = fs.statSync(LOG_FILE);
+    if (st.size < MAX_BYTES) return;
+    const backup = `${LOG_FILE}.1`;
+    try { fs.rmSync(backup, { force: true }); } catch {}
+    try { fs.renameSync(LOG_FILE, backup); } catch {}
+  } catch {
+    // 文件不存在等错误忽略
+  }
+}
+
+/**
+ * 写一条日志：stderr + 可选本地文件
+ * @param {string} msg - 日志内容（不需要带时间戳，本函数自动加）
+ */
+export function log(msg) {
+  // stderr 永远写，兼容 Windsurf Output 面板实时查看
+  console.error(msg);
+
+  if (DISABLED) return;
+
+  ensureInit();
+
+  const line = `[${new Date().toISOString()}] ${msg}\n`;
+  try {
+    rotateIfNeeded();
+    fs.appendFileSync(LOG_FILE, line);
+  } catch (err) {
+    // 文件写失败不能影响主流程，但 stderr 提示一次
+    if (!log._warnedFileFail) {
+      log._warnedFileFail = true;
+      console.error('[logger] 写日志文件失败（后续不再提示）:', err.message);
+    }
+  }
+}
+
+/**
+ * 获取当前日志文件路径（方便 MCP 工具返回给调用方）
+ */
+export function getLogFilePath() {
+  return DISABLED ? null : LOG_FILE;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-log-query-server",
-  "version": "3.5.1",
+  "version": "3.5.2",
   "description": "MCP Server for querying server logs via SSH jump host and Grafana Loki API",
   "main": "index.js",
   "type": "module",
@@ -12,6 +12,7 @@
     "config.js",
     "ssh-client.js",
     "loki-client.js",
+    "logger.js",
     "server-sse.js",
     "README.md"
   ],

package/ssh-client.js

@@ -15,6 +15,7 @@
 
 import { Client } from 'ssh2';
 import { JUMP_HOST, K8S_SERVER, DEFAULTS } from './config.js';
+import { log } from './logger.js';
 
 // ============================================================
 // 并发信号量：防止同时打开过多堡垒机会话被踢
@@ -39,13 +40,13 @@ const _sshSem = {
 function sshAcquire(timeoutMs = SSH_ACQUIRE_TIMEOUT) {
   if (_sshSem.active < _sshSem.max) {
     _sshSem.active++;
-    console.error(`[SSH-Sem] acquire 直接通过 (active=${_sshSem.active}/${_sshSem.max}, queue=${_sshSem.queue.length})`);
+    log(`[SSH-Sem] acquire 直接通过 (active=${_sshSem.active}/${_sshSem.max}, queue=${_sshSem.queue.length})`);
     return Promise.resolve();
   }
   if (_sshSem.queue.length >= _sshSem.queueMax) {
     return Promise.reject(new Error(`SSH 并发队列已满（>${_sshSem.queueMax}），请稍后重试`));
   }
-  console.error(`[SSH-Sem] acquire 进入排队 (active=${_sshSem.active}/${_sshSem.max}, queue=${_sshSem.queue.length + 1}, timeout=${timeoutMs}ms)`);
+  log(`[SSH-Sem] acquire 进入排队 (active=${_sshSem.active}/${_sshSem.max}, queue=${_sshSem.queue.length + 1}, timeout=${timeoutMs}ms)`);
   return new Promise((resolve, reject) => {
     let settled = false;
     const enterQueue = () => {
@@ -53,7 +54,7 @@ function sshAcquire(timeoutMs = SSH_ACQUIRE_TIMEOUT) {
       settled = true;
       clearTimeout(timer);
       _sshSem.active++;
-      console.error(`[SSH-Sem] acquire 出队获得槽位 (active=${_sshSem.active}/${_sshSem.max}, queue=${_sshSem.queue.length})`);
+      log(`[SSH-Sem] acquire 出队获得槽位 (active=${_sshSem.active}/${_sshSem.max}, queue=${_sshSem.queue.length})`);
       resolve();
     };
     _sshSem.queue.push(enterQueue);
@@ -63,7 +64,7 @@ function sshAcquire(timeoutMs = SSH_ACQUIRE_TIMEOUT) {
       // 从队列里移除自己的 entry
       const idx = _sshSem.queue.indexOf(enterQueue);
       if (idx >= 0) _sshSem.queue.splice(idx, 1);
-      console.error(`[SSH-Sem] acquire 排队超时 (${timeoutMs}ms, active=${_sshSem.active}/${_sshSem.max}, queue=${_sshSem.queue.length})`);
+      log(`[SSH-Sem] acquire 排队超时 (${timeoutMs}ms, active=${_sshSem.active}/${_sshSem.max}, queue=${_sshSem.queue.length})`);
       reject(new Error(`SSH 排队等待超时 (${timeoutMs}ms)：前面请求卡住，或并发过高。可调整 SSH_MAX_CONCURRENT / SSH_ACQUIRE_TIMEOUT`));
     }, timeoutMs);
   });
@@ -74,7 +75,7 @@ function sshRelease() {
   // 超时的 entry 已在 timer 里从 queue 移除，这里 shift 到的都是活的
   const next = _sshSem.queue.shift();
   if (next) next();
-  console.error(`[SSH-Sem] release (active=${_sshSem.active}/${_sshSem.max}, queue=${_sshSem.queue.length})`);
+  log(`[SSH-Sem] release (active=${_sshSem.active}/${_sshSem.max}, queue=${_sshSem.queue.length})`);
 }
 
 /**