mm_monitor 1.0.7 → 1.2.0

package/index.js

@@ -1,16 +1,16 @@
 const Monitor = require('./lib/monitor');
-const Admin = require('mm_corejs').Admin;
+const { reg } = require('mm_admin');
 
-const admin = new Admin();
+const admin = reg('mm_monitor');
 admin.setClass(Monitor);
 
 module.exports = {
   Monitor,
   admin,
   monitorAdmin(scope, config = {}) {
-    if (!scope) {
-      scope = 'os';
-    }
-    return admin.get(scope, config);
+    return admin.get(scope || 'os', config);
   }
-};
+};
+/* mm-tool-logic-export 工具能力层：其它模块可 require("<pkg>").tools.<name> 直接引用 */
+Object.defineProperty(module.exports, 'tools', { enumerable: true, configurable: true,
+  get: function () { return require('./lib/tools'); } });

package/lib/tools/health/index.js

@@ -0,0 +1,99 @@
+/**
+ * 健康检查观察器
+ * 通过 os/process 模块读取真实系统状态
+ */
+var os = require('os');
+
+function getDir() {
+  return $?.run_path || process.cwd();
+}
+
+async function main(params, ctx, options) {
+  var checks = params.checks || ['memory', 'cpu', 'disk'];
+  var results = [];
+  var all_healthy = true;
+
+  for (var i = 0; i < checks.length; i++) {
+    var name = checks[i];
+    var result = { name: name };
+
+    switch (name) {
+      case 'memory': {
+        var total = os.totalmem();
+        var free = os.freemem();
+        var used_pct = Math.round((1 - free / total) * 100);
+        result.status = used_pct > 90 ? 'warn' : 'ok';
+        result.value = used_pct + '%';
+        result.detail = { total: total, free: free, used_pct: used_pct };
+        break;
+      }
+      case 'cpu': {
+        var cpus = os.cpus();
+        var load = os.loadavg();
+        result.status = load[0] > cpus.length * 0.8 ? 'warn' : 'ok';
+        result.value = (load[0] || 0).toFixed(2);
+        result.detail = {
+          cores: cpus.length,
+          load_1m: load[0],
+          load_5m: load[1],
+          load_15m: load[2]
+        };
+        break;
+      }
+      case 'disk': {
+        try {
+          var stat = require('fs').statfsSync(getDir());
+          var used_pct = Math.round((1 - stat.bfree / stat.blocks) * 100);
+          result.status = used_pct > 90 ? 'warn' : 'ok';
+          result.value = used_pct + '%';
+          result.detail = {
+            total_blocks: stat.blocks,
+            free_blocks: stat.bfree,
+            used_pct: used_pct
+          };
+        } catch (e) {
+          result.status = 'error';
+          result.value = '';
+          result.detail = { error: e.message };
+          all_healthy = false;
+        }
+        break;
+      }
+      case 'uptime': {
+        var uptime = process.uptime();
+        result.status = 'ok';
+        result.value = Math.floor(uptime) + 's';
+        result.detail = { uptime_seconds: uptime };
+        break;
+      }
+      case 'process': {
+        var mem = process.memoryUsage();
+        result.status = mem.heapUsed / mem.heapTotal > 0.9 ? 'warn' : 'ok';
+        result.value = Math.round(mem.heapUsed / 1024 / 1024) + 'MB';
+        result.detail = {
+          pid: process.pid,
+          heap_used: mem.heapUsed,
+          heap_total: mem.heapTotal,
+          rss: mem.rss
+        };
+        break;
+      }
+      default: {
+        result.status = 'unknown';
+        result.value = '';
+        break;
+      }
+    }
+
+    if (result.status !== 'ok') {
+      all_healthy = false;
+    }
+    results.push(result);
+  }
+
+  ctx.output.health = results;
+  ctx.output = { healthy: all_healthy, checks: results };
+  return ctx.output;
+}
+
+module.exports = { main };

package/lib/tools/index.js

@@ -0,0 +1,16 @@
+'use strict';
+const fs = require('fs');
+const path = require('path');
+/** 模块能力层：懒加载工具实现，避免模块入口被 require 时加载全部实现 */
+module.exports = new Proxy({}, {
+  get(_t, key) {
+    if (typeof key !== 'string') return undefined;
+    if (!fs.existsSync(path.join(__dirname, key, 'index.js'))) return undefined;
+    return require('./' + key);
+  },
+  has(_t, key) {
+    return typeof key === 'string' && fs.existsSync(path.join(__dirname, key, 'index.js'));
+  },
+  ownKeys() { return fs.readdirSync(__dirname, { withFileTypes: true }).filter(e => e.isDirectory()).map(e => e.name); },
+  getOwnPropertyDescriptor(_t, key) { return this.has(_t, key) ? { enumerable: true, configurable: true } : undefined; }
+});

package/lib/tools/monitor/index.js

@@ -0,0 +1,299 @@
+const os = require('os');
+const fs = require('fs');
+const net = require('net');
+const child_process = require('child_process');
+const Http = require('mm_https');
+
+const ACTIONS = ['get_system', 'get_processes', 'check_port', 'check_service'];
+
+module.exports = {
+  /**
+   * 系统监控
+   * @param {object} params 监控参数
+   * @param {string} params.action 操作类型
+   * @param {number} params.top 进程数量
+   * @param {string} params.host 主机地址
+   * @param {number} params.port 端口号
+   * @param {number} params.timeout 超时时间(毫秒)
+   * @param {string} params.url 服务地址
+   * @returns {object} 监控结果
+   */
+  async monitor(params) {
+    let { action } = params;
+    if (!action) {
+      throw new TypeError('操作类型(action)不能为空');
+    }
+    if (ACTIONS.indexOf(action) === -1) {
+      throw new Error('不支持的操作类型: ' + action);
+    }
+    switch (action) {
+      case 'get_system':
+        return await this.getSystem();
+      case 'get_processes':
+        return await this.getProc(params.top);
+      case 'check_port':
+        return await this.checkPort(params.host, params.port, params.timeout);
+      case 'check_service':
+        return await this.checkService(params.url, params.timeout);
+    }
+  },
+
+  /**
+   * 获取系统信息
+   * @returns {object} 系统信息
+   */
+  async getSystem() {
+    return {
+      hostname: os.hostname(),
+      platform: os.platform(),
+      arch: os.arch(),
+      uptime: os.uptime(),
+      cpu: this.getCpu(),
+      memory: this.getMemory(),
+      disk: this.getDisk(),
+      network: this.getNetwork(),
+      loadavg: os.loadavg()
+    };
+  },
+
+  /**
+   * 获取CPU使用率
+   * @returns {object} CPU信息
+   */
+  getCpu() {
+    let cpus = os.cpus();
+    let total = 0;
+    let idle = 0;
+    for (let cpu of cpus) {
+      for (let type in cpu.times) {
+        total += cpu.times[type];
+      }
+      idle += cpu.times.idle;
+    }
+    let usage = total > 0 ? (1 - idle / total) * 100 : 0;
+    return {
+      cores: cpus.length,
+      model: cpus.length > 0 ? cpus[0].model : '',
+      usage_percent: parseFloat(usage.toFixed(1))
+    };
+  },
+
+  /**
+   * 获取内存使用情况
+   * @returns {object} 内存信息
+   */
+  getMemory() {
+    let total = os.totalmem();
+    let free = os.freemem();
+    return {
+      total: total,
+      free: free,
+      used: total - free,
+      usage_percent: total > 0 ? parseFloat(((1 - free / total) * 100).toFixed(1)) : 0
+    };
+  },
+
+  /**
+   * 获取磁盘使用情况
+   * @returns {Array} 磁盘信息列表
+   */
+  getDisk() {
+    let list = [];
+    try {
+      if (typeof fs.statfsSync === 'function') {
+        let stat = fs.statfsSync(process.cwd());
+        let total = stat.blocks * stat.bsize;
+        let free = stat.bavail * stat.bsize;
+        list.push({
+          path: process.cwd(),
+          total: total,
+          free: free,
+          usage_percent: total > 0 ? parseFloat(((1 - free / total) * 100).toFixed(1)) : 0
+        });
+      }
+    } catch (error) {
+      void error;
+      // 获取磁盘失败时返回空列表
+    }
+    return list;
+  },
+
+  /**
+   * 获取网络接口信息
+   * @returns {Array} 网络接口列表
+   */
+  getNetwork() {
+    let list = [];
+    let ifaces = os.networkInterfaces();
+    for (let key in ifaces) {
+      let addrs = ifaces[key];
+      for (let addr of addrs) {
+        if (addr.family === 'IPv4' && !addr.internal) {
+          list.push({ name: key, address: addr.address, mac: addr.mac });
+        }
+      }
+    }
+    return list;
+  },
+
+  /**
+   * 获取进程列表
+   * @param {number} top 进程数量
+   * @returns {object} 进程列表
+   */
+  async getProc(top) {
+    let limit = top || 20;
+    let is_win = process.platform === 'win32';
+    let cmd = is_win ? 'tasklist /FO CSV' : 'ps -eo pid,pcpu,pmem,comm --sort=-pcpu';
+    try {
+      let output = child_process.execSync(cmd, { encoding: 'utf-8', maxBuffer: 5242880 }); // eslint-disable-line mm_eslint/variable-name
+      let list = this.parseProc(output, is_win).slice(0, limit);
+      return { list: list, count: list.length };
+    } catch (error) {
+      void error;
+      return { list: [], count: 0 };
+    }
+  },
+
+  /**
+   * 解析进程输出
+   * @param {string} output 命令输出
+   * @param {boolean} is_win 是否Windows
+   * @returns {Array} 进程列表
+   */
+  parseProc(output, is_win) {
+    let list = [];
+    let lines = output.trim().split('\n');
+    for (let i = 1; i < lines.length; i++) {
+      let line = lines[i].trim();
+      if (!line) {
+        continue;
+      }
+      let item = is_win ? this.parseWinLine(line) : this.parseUnixLine(line);
+      if (item) {
+        list.push(item);
+      }
+    }
+    return list;
+  },
+
+  /**
+   * 解析Windows进程行
+   * @param {string} line 行内容
+   * @returns {object|null} 进程信息
+   */
+  parseWinLine(line) {
+    let cols = line.split('","');
+    if (cols.length < 3) {
+      return null;
+    }
+    let name = cols[0].replace(/"/g, '');
+    let pid = parseInt(cols[1], 10);
+    let mem = cols[cols.length - 1].replace(/"/g, '').replace(/[^\d]/g, '');
+    return {
+      pid: pid,
+      name: name,
+      memory_kb: parseInt(mem, 10) || 0
+    };
+  },
+
+  /**
+   * 解析Unix进程行
+   * @param {string} line 行内容
+   * @returns {object|null} 进程信息
+   */
+  parseUnixLine(line) {
+    let parts = line.trim().split(/\s+/);
+    if (parts.length < 4) {
+      return null;
+    }
+    return {
+      pid: parseInt(parts[0], 10),
+      cpu_percent: parseFloat(parts[1]),
+      mem_percent: parseFloat(parts[2]),
+      name: parts.slice(3).join(' ')
+    };
+  },
+
+  /**
+   * 检测端口是否开放
+   * @param {string} host 主机地址
+   * @param {number} port 端口号
+   * @param {number} timeout 超时时间
+   * @returns {object} 检测结果
+   */
+  checkPort(host, port, timeout) {
+    if (!host) {
+      throw new TypeError('主机(host)不能为空');
+    }
+    if (!port) {
+      throw new TypeError('端口(port)不能为空');
+    }
+    let timeout_ms = timeout || 3000;
+    return new Promise((resolve) => {
+      let socket = net.connect(port, host);
+      socket.setTimeout(timeout_ms);
+      socket.on('connect', () => {
+        socket.destroy();
+        resolve({ open: true, host: host, port: port });
+      });
+      socket.on('timeout', () => {
+        socket.destroy();
+        resolve({ open: false, host: host, port: port });
+      });
+      socket.on('error', () => {
+        resolve({ open: false, host: host, port: port });
+      });
+    });
+  },
+
+  /**
+   * 检测HTTP服务连通性
+   * @param {string} url 服务地址
+   * @param {number} timeout 超时时间
+   * @returns {object} 检测结果
+   */
+  async checkService(url, timeout) {
+    if (!url) {
+      throw new TypeError('服务地址(url)不能为空');
+    }
+    try {
+      let http = new Http({ rejectUnauthorized: false }); // eslint-disable-line mm_eslint/variable-name
+      let start = Date.now();
+      let res = await http.get(url);
+      let cost = Date.now() - start;
+      let status = typeof res.status === 'number' ? res.status : (res.status && res.status.code);
+      return {
+        ok: status >= 200 && status < 500,
+        url: url,
+        status: status || 0,
+        ms: cost
+      };
+    } catch (error) {
+      return { ok: false, url: url, status: 0, ms: 0, msg: error.message };
+    }
+  },
+
+  /**
+   * 主函数
+   * @param {object} params 参数
+   * @returns {object} 执行结果
+   */
+  async main(params, ctx, options) {
+    try {
+      let result = await this.monitor(params);
+      return { code: 0, msg: '操作成功', data: result };
+    } catch (error) {
+      return {
+        code: 10000,
+        msg: '系统监控失败！原因：' + error.message,
+        data: null,
+        error: {
+          name: error.name,
+          message: error.message,
+          stack: error.stack
+        }
+      };
+    }
+  }
+};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "mm_monitor",
-    "version": "1.0.7",
+    "version": "1.2.0",
     "description": "超级美眉监听器，用于监听网站运行是否异常并给运维人员发短信、邮箱通知",
     "main": "index.js",
     "scripts": {
@@ -22,8 +22,8 @@
         "render",
         "template"
     ],
-    "layer": "crosscut",
-    "group": "alerting",
+    "layer": "infrastructure",
+    "group": "observability",
     "author": "邱文武",
     "license": "ISC",
     "bugs": {
@@ -31,7 +31,7 @@
     },
     "homepage": "https://gitee.com/qiuwenwu91/mm_monitor#readme",
     "dependencies": {
-        "mm_corejs": "^1.1.4",
+        "mm_admin": "^1.1.0",
         "mm_email": "^1.1.0",
         "mm_helper": "^1.0.3",
         "mm_https": "^1.7.1",

package/tool/health/index.js

@@ -0,0 +1,7 @@
+'use strict';
+/**
+ * health —— 工具契约适配层
+ * 业务实现归位于模块 lib/tools/health/，本文件只把模块能力暴露给加载器。
+ * 其它模块可直接 require('mm_monitor').tools.health 复用。
+ */
+module.exports = require('../../lib/tools/health');

package/tool/health/tool.json

@@ -0,0 +1,46 @@
+{
+  "name": "health",
+  "handler": "observer",
+  "title": "健康检查观察器",
+  "description": "检查系统各组件的健康状态（内存/CPU/磁盘等）。适用场景：系统体检、运维监控或启动前置检查时。工作流提示：checks 指定待检查组件列表（默认 memory/cpu/disk），返回 healthy 判断整体是否健康、checks 为各组件检查结果。",
+  "type": "data",
+  "params": {
+    "type": "object",
+    "properties": {
+      "checks": {
+        "type": "array",
+        "description": "待检查组件列表，默认 ['memory', 'cpu', 'disk']"
+      }
+    }
+  },
+  "returns": {
+    "type": "object",
+    "description": "健康检查结果",
+    "properties": {
+      "healthy": {
+        "type": "boolean",
+        "description": "系统是否健康"
+      },
+      "checks": {
+        "type": "array",
+        "description": "检查结果列表"
+      },
+      "error": {
+        "type": "object",
+        "description": "错误信息，仅调用出错时返回",
+        "properties": {
+          "code": {
+            "type": "string",
+            "description": "错误码"
+          },
+          "message": {
+            "type": "string",
+            "description": "错误描述"
+          }
+        }
+      }
+    }
+  },
+  "options": {},
+  "group": "monitor"
+}

package/tool/monitor/index.js

@@ -0,0 +1,7 @@
+'use strict';
+/**
+ * monitor —— 工具契约适配层
+ * 业务实现归位于模块 lib/tools/monitor/，本文件只把模块能力暴露给加载器。
+ * 其它模块可直接 require('mm_monitor').tools.monitor 复用。
+ */
+module.exports = require('../../lib/tools/monitor');

package/tool/monitor/tool.json

@@ -0,0 +1,73 @@
+{
+  "name": "monitor",
+  "title": "系统监控",
+  "description": "监控系统CPU、内存、磁盘、网络、进程，检测端口开放和服务连通性。触发关键词：系统监控、CPU使用率、内存使用、磁盘空间、进程列表、端口检测、服务检测",
+  "category": "系统工具",
+  "group": "system",
+  "type": "function",
+  "main": "./index.js",
+  "params": {
+    "type": "object",
+    "properties": {
+      "action": {
+        "type": "string",
+        "description": "操作类型：get_system(系统信息)/get_processes(进程列表)/check_port(端口检测)/check_service(服务检测)",
+        "enum": [
+          "get_system",
+          "get_processes",
+          "check_port",
+          "check_service"
+        ]
+      },
+      "top": {
+        "type": "integer",
+        "description": "进程数量（action=get_processes时有效，默认20）",
+        "default": 20
+      },
+      "host": {
+        "type": "string",
+        "description": "主机地址（action=check_port时必填）"
+      },
+      "port": {
+        "type": "integer",
+        "description": "端口号（action=check_port时必填）"
+      },
+      "url": {
+        "type": "string",
+        "description": "服务地址（action=check_service时必填）"
+      },
+      "timeout": {
+        "type": "integer",
+        "description": "超时时间（毫秒，默认3000）",
+        "default": 3000
+      }
+    },
+    "required": [
+      "action"
+    ]
+  },
+  "returns": {
+    "type": "object",
+    "properties": {
+      "code": {
+        "type": "number",
+        "description": "返回代码，0表示成功",
+        "default": 0
+      },
+      "msg": {
+        "type": "string",
+        "description": "返回消息",
+        "default": ""
+      },
+      "data": {
+        "type": "object",
+        "description": "监控结果数据"
+      }
+    },
+    "required": [
+      "code",
+      "msg"
+    ]
+  },
+  "handler": "manager"
+}