mm_os 3.2.4 → 3.2.5

package/conf.json

@@ -1,3 +1,3 @@
 {
-    "runPath": "E:\\gitee\\1_doing\\mm\\mm_sos\\demo"
+    "runPath": "E:\\gitee\\1_doing\\mm\\mm_os"
 }

package/core/base/mqtt/index.js

@@ -154,7 +154,7 @@ MQTT.prototype.use = function(func) {
  */
 MQTT.prototype.main = function(state) {
 	var cg = this.config;
-	sr = this.server;
+	var sr = this.server;
 
 	var _this = this;
 
@@ -239,46 +239,144 @@ MQTT.prototype.published = function(packet, client) {
 };
 
 /**
- * 身份验证
+ * 身份验证 - 使用MySQL数据库验证
  * @param {Object} client 客户端
  * @param {String} username 用户名
  * @param {String} password 密码
  * @param {Function} callback 回调函数，回调返回true，则表示验证通过。
  */
 MQTT.prototype.auth = function(client, username, password, callback) {
-	// console.log("连接授权", client.id, username, password ? password.toString() : '');
-	var bl = true;
-	// 回调第二个参数为true表示验证通过, 为false表示验证失败
-	callback(null, bl);
+	// 密码可能是Buffer类型，需要转换为字符串
+	const passwordStr = password ? password.toString() : '';
+	
+	// 检查必要参数
+	if (!username || !passwordStr) {
+		console.warn(`MQTT客户端 ${client.id} 身份验证失败：用户名或密码为空`);
+		callback(null, false);
+		return;
+	}
+	
+	// 检查是否有可用的MySQL连接
+	if (!$.sql || typeof $.sql.query !== 'function') {
+		console.error(`MQTT客户端 ${client.id} 身份验证错误：MySQL连接不可用`);
+		callback(null, false);
+		return;
+	}
+	
+	// 使用参数化查询以防止SQL注入
+	const sql = `SELECT password FROM mqtt_users WHERE username = ? LIMIT 1`;
+	const params = [username];
+	
+	// 执行查询验证用户
+	$.sql.query(sql, params, (err, results) => {
+		if (err) {
+			console.error(`MQTT客户端 ${client.id} 身份验证数据库错误:`, err);
+			callback(null, false);
+			return;
+		}
+		
+		// 检查用户是否存在
+		if (!results || results.length === 0) {
+			console.warn(`MQTT客户端 ${client.id} 身份验证失败：用户不存在，用户名: ${username}`);
+			callback(null, false);
+			return;
+		}
+		
+		// 获取数据库中的密码
+		const dbPassword = results[0].password;
+		
+		// 验证密码
+		// 注意：在实际应用中，应该使用bcrypt等密码哈希算法进行验证，而不是明文比较
+		// 如果数据库中存储的是哈希密码，需要使用相应的哈希算法进行验证
+		try {
+			// 尝试使用bcrypt验证（如果已安装bcrypt模块）
+			const bcrypt = require('bcrypt');
+			const isMatch = bcrypt.compareSync(passwordStr, dbPassword);
+			
+			if (isMatch) {
+				console.info(`MQTT客户端 ${client.id} 身份验证成功，用户: ${username}`);
+			} else {
+				console.warn(`MQTT客户端 ${client.id} 身份验证失败：密码不匹配，用户名: ${username}`);
+			}
+			
+			callback(null, isMatch);
+		} catch (err) {
+			// 如果bcrypt不可用，回退到简单的密码比较（不推荐在生产环境中使用）
+			console.warn('bcrypt模块不可用，使用简单密码比较');
+			const isMatch = dbPassword === passwordStr;
+			
+			if (isMatch) {
+				console.info(`MQTT客户端 ${client.id} 身份验证成功，用户: ${username}`);
+			} else {
+				console.warn(`MQTT客户端 ${client.id} 身份验证失败：密码不匹配，用户名: ${username}`);
+			}
+			
+			callback(null, isMatch);
+		}
+	});
 };
 
 /**
  * 验证发布，决定客户端可以发布哪些主题
  * @param {Object} client 客户端
- * @param {String} topic 用户名
+ * @param {String} topic 主题
  * @param {Object} payload 参数
  * @param {Function} callback 回调函数，回调返回true，则表示验证通过。
  */
 MQTT.prototype.authPublish = function(client, topic, payload, callback) {
-	var bl = true;
-	// if(topic == "temperature"){
-	// 	bl = false;
-	// }
-	// console.log('收到推送', client.id, topic, payload.toString());
+	// 示例：可以基于客户端ID或用户名实现更细粒度的权限控制
+	// 在实际应用中，应该从数据库或配置中获取客户端的发布权限
+	let isAllowed = true;
+	
+	// 例如：限制某些敏感主题只能由管理员发布
+	const sensitiveTopics = ['system/settings', 'admin/commands'];
+	const isSensitiveTopic = sensitiveTopics.some(sensitiveTopic => 
+		 topic === sensitiveTopic || topic.startsWith(sensitiveTopic + '/')
+	);
+	
+	// 简单示例：检查客户端ID是否表示管理员客户端
+	const isAdminClient = client.id === 'admin_client' || client.id.startsWith('admin_');
+	
+	if (isSensitiveTopic && !isAdminClient) {
+		isAllowed = false;
+		console.warn(`MQTT客户端 ${client.id} 被拒绝发布到敏感主题: ${topic}`);
+	}
+	
 	// 回调第二个参数为true表示验证通过, 为false表示验证失败
-	callback(null, bl);
+	callback(null, isAllowed);
 };
 
 /**
  * 验证订阅，决定客户端可以订阅哪些主题
  * @param {Object} client 客户端
- * @param {String} topic 用户名
+ * @param {String} topic 主题
  * @param {Function} callback 回调函数，回调返回true，则表示验证通过。
  */
 MQTT.prototype.authSubscribe = function(client, topic, callback) {
-	var bl = true;
+	// 示例：可以基于客户端ID或用户名实现更细粒度的权限控制
+	// 在实际应用中，应该从数据库或配置中获取客户端的订阅权限
+	let isAllowed = true;
+	
+	// 例如：限制某些敏感主题只能由特定客户端订阅
+	const restrictedTopics = ['private/data', 'user/+/profile'];
+	const isRestrictedTopic = restrictedTopics.some(restrictedTopic => {
+		// 处理通配符，例如：user/+/profile 匹配 user/123/profile, user/456/profile 等
+		const pattern = restrictedTopic.replace(/\+/g, '[^/]+');
+		const regex = new RegExp(`^${pattern}$`);
+		return regex.test(topic);
+	});
+	
+	// 简单示例：允许特定客户端订阅受限主题
+	const allowedClients = ['trusted_client', 'monitoring_service'];
+	const isAllowedClient = allowedClients.includes(client.id);
+	
+	if (isRestrictedTopic && !isAllowedClient) {
+		isAllowed = false;
+		console.warn(`MQTT客户端 ${client.id} 被拒绝订阅受限主题: ${topic}`);
+	}
+	
 	// 回调第二个参数为true表示验证通过, 为false表示验证失败
-	callback(null, bl);
+	callback(null, isAllowed);
 };
 
 /**

package/core/base/web/index.js

@@ -50,6 +50,38 @@ WEB.prototype.init = function(config) {
 		this.config = Object.assign(this.config, config);
 	}
 	this.server = new Koa();
+	
+	// 添加统一错误处理中间件（确保是第一个被注册的中间件）
+	this.server.use(async (ctx, next) => {
+		try {
+			await next();
+			// 处理404错误
+			if (ctx.status === 404 && !ctx.body) {
+				ctx.status = 404;
+				ctx.body = { code: 404, message: 'Not Found' };
+			}
+		} catch (error) {
+			// 统一错误处理逻辑
+			const status = error.status || 500;
+			const message = error.message || 'Internal Server Error';
+			
+			// 根据环境决定是否返回详细错误信息
+			const errorInfo = process.env.NODE_ENV === 'production' 
+				? { message } 
+				: { message, stack: error.stack };
+			
+			ctx.status = status;
+			ctx.body = { code: status, ...errorInfo };
+			
+			// 记录错误日志
+			if ($.log && $.log.error) {
+				$.log.error(`请求错误 [${ctx.method} ${ctx.path}]:`, error);
+			} else {
+				console.error(`请求错误 [${ctx.method} ${ctx.path}]:`, error);
+			}
+		}
+	});
+	
 	return this;
 };
 
@@ -71,9 +103,23 @@ WEB.prototype.main = function(state) {
 	if (host == '0.0.0.0') {
 		host = '127.0.0.1'
 	}
-	this.server.listen(cg.port, cg.host, () => {
+	
+	// 启动HTTP服务器
+	const httpServer = this.server.listen(cg.port, cg.host, () => {
 		console.info(`HTTP访问 http://${host}:${cg.port}`);
 	});
+	
+	// 监听服务器错误事件
+	httpServer.on('error', (error) => {
+		if ($.log && $.log.error) {
+			$.log.error('Web服务器错误:', error);
+		} else {
+			console.error('Web服务器错误:', error);
+		}
+	});
+	
+	// 保存服务器实例引用，方便后续操作
+	this.httpServer = httpServer;
 };
 
 /**

package/core/com/mqtt/index.js

@@ -27,8 +27,8 @@ class MQTT extends Index {
 			port: "1883",
 			protocol: "mqtt",
 			clientId: "iot_test",
-			subscribe_qos: 1,
-			publish_qos: 1,
+			subscribe_qos: 2,
+			publish_qos: 2,
 			username: "iot_test",
 			password: "asd123",
 			table: "iot_device",
@@ -263,7 +263,7 @@ MQTT.prototype.receive = async function(push_topic, msg) {
 		try {
 			msg = JSON.parse(msg);
 		} catch (error) {
-			$.log.error("消息结构体不对", error);
+			$.log.error("消息结构体不对", push_topic, error);
 		}
 	}
 	var ret;

package/index.js

@@ -41,7 +41,13 @@ class OS {
 				"static": true,
 				"maxAge": 7200,
 				"static_path": "./static",
-				"proxy": {}
+				"proxy": {},
+				"rateLimit": {
+					"windowMs": 15 * 60 * 1000, // 时间窗口，默认15分钟
+					"maxRequests": 100,         // 每个时间窗口内的最大请求数
+					"message": "请求过于频繁，请稍后再试", // 超过限制时的提示信息
+					"statusCode": 429           // 超过限制时的HTTP状态码
+				}
 			},
 			"mqtt": {
 				"state": true,
@@ -158,6 +164,29 @@ OS.prototype.loadModule = function(cg) {
 	}
 }
 
+/**
+ * 初始化全局错误处理机制
+ */
+OS.prototype.initErrorHandler = function() {
+	// 全局未捕获异常处理
+	process.on('uncaughtException', (error) => {
+		if ($.log && $.log.error) {
+			$.log.error('全局未捕获异常:', error);
+		} else {
+			console.error('全局未捕获异常:', error);
+		}
+	});
+	
+	// 全局未处理Promise拒绝处理
+	process.on('unhandledRejection', (reason, promise) => {
+		if ($.log && $.log.error) {
+			$.log.error('全局未处理Promise拒绝:', reason);
+		} else {
+			console.error('全局未处理Promise拒绝:', reason);
+		}
+	});
+};
+
 /**
  * 初始化
  * @param {Object} config - 配置参数
@@ -166,7 +195,19 @@ OS.prototype.init = function(config) {
 	this.config = Object.assign(this.config, config);
 	this.initData(this.config);
 	this.loadModule(this.config);
+	// 提供简单的日志功能替代方案
+	if (!$.log) {
+		$.log = {
+			debug: console.debug,
+			info: console.info,
+			warn: console.warn,
+			error: console.error,
+			log: console.log
+		};
+	}
 	this.initBase(this.config);
+	// 初始化全局错误处理机制
+	this.initErrorHandler();
 }
 
 /**

package/middleware/cors/index.js

@@ -9,73 +9,91 @@ module.exports = function(server, config) {
 		if (cos.headers && cos.origin !== "*") {
 			/* 跨域限制（web防火墙） */
 			server.use(async (ctx, next) => {
-				var req = ctx.request;
+				try {
+					var req = ctx.request;
 
-				// 允许来自所有域名请求
-				ctx.set('Access-Control-Allow-Origin', cos.origin);
-				// 这样就能只允许 http://localhost:8080 这个域名的请求了
-				// ctx.set("Access-Control-Allow-Origin", "http://localhost:8080");
+					// 允许来自所有域名请求
+					ctx.set('Access-Control-Allow-Origin', cos.origin);
+					// 这样就能只允许 http://localhost:8080 这个域名的请求了
+					// ctx.set("Access-Control-Allow-Origin", "http://localhost:8080");
 
-				// 字段是必需的。它也是一个逗号分隔的字符串，表明服务器支持的所有头信息字段.
-				if (req.method == "OPTIONS") {
-					ctx.set('Access-Control-Allow-Headers', cos.headers);
+					// 字段是必需的。它也是一个逗号分隔的字符串，表明服务器支持的所有头信息字段.
+					if (req.method == "OPTIONS") {
+						ctx.set('Access-Control-Allow-Headers', cos.headers);
 
-					// 服务器收到请求以后，检查了Origin、Access-Control-Request-Method和Access-Control-Request-Headers字段以后，确认允许跨源请求，就可以做出回应。
-					// Content-Type表示具体请求中的媒体类型信息
-					// ctx.set("Content-Type", "application/json;charset=utf-8");
-					// 设置所允许的HTTP请求方法PUT,POST,GET,DELETE,HEAD,OPTIONS
-					// ctx.set('Access-Control-Allow-Methods', 'GET,POST');
+						// 服务器收到请求以后，检查了Origin、Access-Control-Request-Method和Access-Control-Request-Headers字段以后，确认允许跨源请求，就可以做出回应。
+						// Content-Type表示具体请求中的媒体类型信息
+						// ctx.set("Content-Type", "application/json;charset=utf-8");
+						// 设置所允许的HTTP请求方法PUT,POST,GET,DELETE,HEAD,OPTIONS
+						// ctx.set('Access-Control-Allow-Methods', 'GET,POST');
 
-					// 该字段可选。它的值是一个布尔值，表示是否允许发送Cookie。默认情况下，Cookie不包括在CORS请求之中。
-					// 当设置成允许请求携带cookie时，需要保证"Access-Control-Allow-Origin"是服务器有的域名，而不能是"*";
-					// ctx.set("Access-Control-Allow-Credentials", 'false');
+						// 该字段可选。它的值是一个布尔值，表示是否允许发送Cookie。默认情况下，Cookie不包括在CORS请求之中。
+						// 当设置成允许请求携带cookie时，需要保证"Access-Control-Allow-Origin"是服务器有的域名，而不能是"*";
+						// ctx.set("Access-Control-Allow-Credentials", 'false');
 
-					// 该字段可选，用来指定本次预检请求的有效期，单位为秒。
-					// 当请求方法是PUT或DELETE等特殊方法或者Content-Type字段的类型是application/json时，服务器会提前发送一次请求进行验证
-					// 下面的的设置只本次验证的有效时间，即在该时间段内服务端可以不用进行验证
-					// ctx.set("Access-Control-Max-Age", '3600');
-					/*
-					CORS请求时，XMLHttpRequest对象的getResponseHeader()方法只能拿到6个基本字段：
-					    Cache-Control、
-					    Content-Language、
-					    Content-Type、
-					    Expires、
-					    Last-Modified、
-					    Pragma
-					*/
-					// 需要获取其他字段时，使用Access-Control-Expose-Headers，
-					// getResponseHeader('myData')可以返回我们所需的值
-					// ctx.set("Access-Control-Expose-Headers", "myData");
-					ctx.status = 204;
-				} else {
+						// 该字段可选，用来指定本次预检请求的有效期，单位为秒。
+						// 当请求方法是PUT或DELETE等特殊方法或者Content-Type字段的类型是application/json时，服务器会提前发送一次请求进行验证
+						// 下面的的设置只本次验证的有效时间，即在该时间段内服务端可以不用进行验证
+						// ctx.set("Access-Control-Max-Age", '3600');
+						/*
+						CORS请求时，XMLHttpRequest对象的getResponseHeader()方法只能拿到6个基本字段：
+						    Cache-Control、
+						    Content-Language、
+						    Content-Type、
+						    Expires、
+						    Last-Modified、
+						    Pragma
+						*/
+						// 需要获取其他字段时，使用Access-Control-Expose-Headers，
+						// getResponseHeader('myData')可以返回我们所需的值
+						// ctx.set("Access-Control-Expose-Headers", "myData");
+						ctx.status = 204;
+					} else {
+						await next();
+					}
+				} catch (error) {
+					$.log.error('CORS中间件错误(origin限制):', error);
+					// 出错时默认允许请求继续处理
 					await next();
 				}
 			});
 		} else if (cos.headers && cos.headers !== "*") {
 			/* 跨域限制（web防火墙） */
 			server.use(async (ctx, next) => {
-				var req = ctx.request;
-				// 允许来自所有域名请求
-				ctx.set('Access-Control-Allow-Origin', '*');
-				// ctx.set('Access-Control-Allow-Methods', 'GET,POST,OPTIONS');
-				if (req.method === 'OPTIONS') {
-					ctx.set('Access-Control-Allow-Headers', cos.headers);
-					ctx.status = 204;
-				} else {
+				try {
+					var req = ctx.request;
+					// 允许来自所有域名请求
+					ctx.set('Access-Control-Allow-Origin', '*');
+					// ctx.set('Access-Control-Allow-Methods', 'GET,POST,OPTIONS');
+					if (req.method === 'OPTIONS') {
+						ctx.set('Access-Control-Allow-Headers', cos.headers);
+						ctx.status = 204;
+					} else {
+						await next();
+					}
+				} catch (error) {
+					$.log.error('CORS中间件错误(headers限制):', error);
+					// 出错时默认允许请求继续处理
 					await next();
 				}
 			});
 		} else {
 			/* 跨域限制（web防火墙） */
 			server.use(async (ctx, next) => {
-				var req = ctx.request;
-				// 允许来自所有域名请求
-				ctx.set('Access-Control-Allow-Origin', '*');
-				// ctx.set('Access-Control-Allow-Methods', 'GET,POST,OPTIONS');
-				if (req.method === 'OPTIONS') {
-					ctx.set('Access-Control-Allow-Headers', '*');
-					ctx.status = 204;
-				} else {
+				try {
+					var req = ctx.request;
+					// 允许来自所有域名请求
+					ctx.set('Access-Control-Allow-Origin', '*');
+					// ctx.set('Access-Control-Allow-Methods', 'GET,POST,OPTIONS');
+					if (req.method === 'OPTIONS') {
+						ctx.set('Access-Control-Allow-Headers', '*');
+						ctx.status = 204;
+					} else {
+						await next();
+					}
+				} catch (error) {
+					$.log.error('CORS中间件错误(完全宽松):', error);
+					// 出错时默认允许请求继续处理
 					await next();
 				}
 			});

package/middleware/log/index.js

@@ -6,16 +6,27 @@
 module.exports = function(server, config) {
 	/* 跨域限制（web防火墙） */
 	server.use(async (ctx, next) => {
-		var url = ctx.path + ctx.querystring;
-		var body = "";
-		if (ctx.request.body) {
-			body = JSON.stringify(ctx.request.body);
-			if (body.length > 1024) {
-				body = body.substring(0, 1024) + "..."
+		try {
+			var url = ctx.path + ctx.querystring;
+			var body = "";
+			if (ctx.request.body) {
+				try {
+					body = JSON.stringify(ctx.request.body);
+					if (body.length > 1024) {
+						body = body.substring(0, 1024) + "..."
+					}
+				} catch (jsonError) {
+					body = "[无法序列化请求体]";
+					$.log.error('日志中间件JSON序列化错误:', jsonError);
+				}
 			}
+			$.log.http(`${ctx.method}\t${url}\t${body}`);
+			await next();
+		} catch (error) {
+			$.log.error('log中间件错误:', error);
+			// 确保请求可以继续处理
+			await next();
 		}
-		$.log.http(`${ctx.method}	${url}	${body}`);
-		await next();
 	});
 	return server;
 };

package/middleware/performance/index.js

@@ -0,0 +1,143 @@
+/**
+ * 请求性能监控中间件
+ * 记录请求响应时间，监控慢请求，提供性能数据收集
+ */
+module.exports = function(server, config) {
+  if(config.web && !config.web.performance) {
+    return server;
+  }
+  
+  // 默认配置
+  const cg = Object.assign({
+    slowThreshold: 1000, // 慢请求阈值，单位毫秒
+    enableMetrics: true, // 是否启用性能指标收集
+    ignorePaths: []      // 忽略监控的路径
+  }, config);
+  
+  // 性能监控数据收集器
+  const performanceData = {
+    counters: new Map(), // 请求计数器
+    responseTimes: new Map(), // 响应时间数据
+    slowRequests: [] // 慢请求记录
+  };
+  
+  // 全局性能监控对象
+  $.performanceMonitor = {
+    record: function(path, responseTime) {
+      if (!cg.enableMetrics) return;
+      
+      // 更新请求计数
+      if (!performanceData.counters.has(path)) {
+        performanceData.counters.set(path, 1);
+        performanceData.responseTimes.set(path, { sum: responseTime, count: 1, min: responseTime, max: responseTime });
+      } else {
+        performanceData.counters.set(path, performanceData.counters.get(path) + 1);
+        const stats = performanceData.responseTimes.get(path);
+        stats.sum += responseTime;
+        stats.count += 1;
+        stats.min = Math.min(stats.min, responseTime);
+        stats.max = Math.max(stats.max, responseTime);
+      }
+      
+      // 记录慢请求
+      if (responseTime > cg.slowThreshold) {
+        performanceData.slowRequests.push({
+          path: path,
+          time: new Date(),
+          responseTime: responseTime
+        });
+        // 限制慢请求记录数量
+        if (performanceData.slowRequests.length > 1000) {
+          performanceData.slowRequests.shift();
+        }
+      }
+    },
+    
+    getStats: function() {
+      const result = {};
+      performanceData.counters.forEach((count, path) => {
+        const times = performanceData.responseTimes.get(path);
+        result[path] = {
+          count: count,
+          avg: times.sum / times.count,
+          min: times.min,
+          max: times.max
+        };
+      });
+      return result;
+    },
+    
+    getSlowRequests: function(limit = 100) {
+      return performanceData.slowRequests.slice(-limit);
+    },
+    
+    reset: function() {
+      performanceData.counters.clear();
+      performanceData.responseTimes.clear();
+      performanceData.slowRequests = [];
+    }
+  };
+  
+  // 性能监控中间件
+  server.use(async (ctx, next) => {
+    // 检查是否需要忽略此路径
+    const shouldIgnore = cg.ignorePaths.some(pattern => {
+      if (typeof pattern === 'string') {
+        return ctx.path === pattern;
+      } else if (pattern instanceof RegExp) {
+        return pattern.test(ctx.path);
+      }
+      return false;
+    });
+    
+    if (shouldIgnore) {
+      await next();
+      return;
+    }
+    
+    const start = Date.now();
+    const startTime = process.hrtime();
+    
+    try {
+      await next();
+    } finally {
+      const ms = Date.now() - start;
+      const [seconds, nanoseconds] = process.hrtime(startTime);
+      const executionTime = seconds * 1000 + nanoseconds / 1000000;
+      
+      // 设置响应时间头
+      ctx.set('X-Response-Time', `${ms}ms`);
+      
+      // 记录性能数据
+      $.performanceMonitor.record(ctx.path, ms);
+      
+      // 慢请求报警
+      if (ms > cg.slowThreshold) {
+        const clientIP = ctx.headers['x-forwarded-for'] || ctx.ip;
+        $.log.warn(`【慢请求】 ${ctx.method} ${ctx.path} - ${ms}ms - ${clientIP}`);
+        
+        // 如果是非常慢的请求（超过阈值的2倍），记录更多信息
+        if (ms > cg.slowThreshold * 2) {
+          const userAgent = ctx.headers['user-agent'] || 'unknown';
+          let requestData = '';
+          try {
+            if (ctx.method !== 'GET' && ctx.request.body) {
+              const bodyStr = JSON.stringify(ctx.request.body);
+              // 限制记录的请求体大小
+              requestData = bodyStr.length > 1024 ? bodyStr.substring(0, 1024) + '...' : bodyStr;
+            }
+          } catch (e) {
+            requestData = '[无法序列化请求体]';
+          }
+          
+          $.log.warn(`【慢请求详情】路径: ${ctx.path}, 方法: ${ctx.method}, 耗时: ${ms}ms, IP: ${clientIP}, UA: ${userAgent.substring(0, 200)}`);
+          if (requestData) {
+            $.log.warn(`【慢请求数据】${requestData}`);
+          }
+        }
+      }
+    }
+  });
+  
+  return server;
+};

package/middleware/performance/middleware.json

@@ -0,0 +1,16 @@
+{
+  "name": "performance",
+  "title": "性能监控",
+  "description": "记录请求响应时间，监控慢请求，提供性能数据收集",
+  "mode": "web",
+  "priority": 10,
+  "config": {
+    "slowThreshold": 1000,
+    "enableMetrics": true,
+    "ignorePaths": [
+      "/favicon.ico",
+      "/robots.txt",
+      "/static/"
+    ]
+  }
+}