mm_redis 2.0.9 → 2.1.0

package/index.js

@@ -98,7 +98,7 @@ Redis.prototype.subscribe = async function (channel, func) {
 		this.func_list[channel] = func;
 		return true;
 	} catch (err) {
-		this.logger('error', `订阅频道 ${channel} 失败:`, err);
+		this.log('error', `订阅频道 ${channel} 失败:`, err);
 		return false;
 	}
 };
@@ -119,7 +119,7 @@ Redis.prototype.unsubscribe = async function (channel) {
 		delete this.func_list[channel];
 		return true;
 	} catch (err) {
-		this.logger('error', `取消订阅频道 ${channel} 失败:`, err);
+		this.log('error', `取消订阅频道 ${channel} 失败:`, err);
 		return false;
 	}
 };
@@ -142,7 +142,7 @@ Redis.prototype.publish = async function (channel, message) {
 	try {
 		return await this.conn.publish(this._addPrefix(channel), message);
 	} catch (err) {
-		this.logger('error', `发布消息到频道 ${channel} 失败:`, err);
+		this.log('error', `发布消息到频道 ${channel} 失败:`, err);
 		return false;
 	}
 };
@@ -154,7 +154,7 @@ Redis.prototype.publish = async function (channel, message) {
  */
 Redis.prototype.main = async function (channel, message) {
 	// 默认实现，可由子类重写
-	this.logger('debug', `收到未处理的消息 [${channel}]:`, message);
+	this.log('debug', `收到未处理的消息 [${channel}]:`, message);
 };
 
 /**
@@ -170,7 +170,7 @@ Redis.prototype.message = function (channel, message) {
 		try {
 			func(message);
 		} catch (err) {
-			this.logger('error', `处理频道 ${channel} 的消息时出错:`, err);
+			this.log('error', `处理频道 ${channel} 的消息时出错:`, err);
 		}
 	} else {
 		this.main(channel, message);
@@ -194,7 +194,7 @@ Redis.prototype.setConfig = function (config) {
 
 	// 初始化连接池
 	this._initPool();
-	// this.logger('debug','配置已更新');
+	// this.log('debug','配置已更新');
 	this.identifier = this.config.host + "/" + this.config.database;
 	return this;
 };
@@ -211,7 +211,7 @@ Redis.prototype._initPool = function () {
 	};
 
 	// 记录连接池初始化
-	// this.logger('debug','连接池已初始化，配置:', this.config);
+	// this.log('debug','连接池已初始化，配置:', this.config);
 };
 
 /**
@@ -240,7 +240,7 @@ Redis.prototype.open = async function () {
 
 		// 监听错误事件
 		this.conn.on('error', (err) => {
-			this.logger('error', 'Redis连接错误:', err);
+			this.log('error', 'Redis连接错误:', err);
 			this.connected = false;
 			// 尝试重连
 			this._reconnect();
@@ -248,25 +248,25 @@ Redis.prototype.open = async function () {
 
 		// 监听连接成功事件
 		this.conn.on('connect', () => {
-			// this.logger('debug','Redis已连接');
+			// this.log('debug','Redis已连接');
 			this.connected = true;
 			this.retry_count = 0;
 		});
 
 		// 监听断开连接事件
 		this.conn.on('end', () => {
-			// this.logger('debug','Redis连接已断开');
+			// this.log('debug','Redis连接已断开');
 			this.connected = false;
 		});
 
 		// 监听订阅成功事件
 		this.conn.on('subscribe', (channel, count) => {
-			this.logger('debug', `频道${this._delPrefix(channel)}订阅成功, 当前总计订阅数：${count}`);
+			this.log('debug', `频道${this._delPrefix(channel)}订阅成功, 当前总计订阅数：${count}`);
 		});
 
 		// 监听取消订阅事件
 		this.conn.on('unsubscribe', (channel, count) => {
-			this.logger('debug', `频道${this._delPrefix(channel)}取消订阅, 当前总计订阅数：${count}`);
+			this.log('debug', `频道${this._delPrefix(channel)}取消订阅, 当前总计订阅数：${count}`);
 		});
 
 		// 收到消息后执行回调
@@ -279,7 +279,7 @@ Redis.prototype.open = async function () {
 		this.connected = true;
 		return true;
 	} catch (err) {
-		this.logger('error', 'Redis连接失败:', err);
+		this.log('error', 'Redis连接失败:', err);
 		// 尝试重连
 		this._reconnect();
 		return false;
@@ -292,18 +292,18 @@ Redis.prototype.open = async function () {
  */
 Redis.prototype._reconnect = function () {
 	if (this.retry_count >= this.config.retry_count) {
-		this.logger('error', `达到最大重连次数 ${this.config.retry_count}，停止重连`);
+		this.log('error', `达到最大重连次数 ${this.config.retry_count}，停止重连`);
 		return;
 	}
 
 	this.retry_count++;
-	this.logger('debug', `尝试第 ${this.retry_count} 次重连...`);
+	this.log('debug', `尝试第 ${this.retry_count} 次重连...`);
 
 	setTimeout(async () => {
 		try {
 			await this.open();
 		} catch (err) {
-			this.logger('error', `重连失败:`, err);
+			this.log('error', `重连失败:`, err);
 		}
 	}, this.config.retry_delay);
 };
@@ -315,7 +315,7 @@ Redis.prototype._reconnect = function () {
 // 修复close方法，正确处理连接池
 Redis.prototype.close = function () {
 	try {
-		// this.logger('debug','关闭所有连接...');
+		// this.log('debug','关闭所有连接...');
 
 		// 关闭所有使用中的连接
 		if (this.connection_pool && this.connection_pool.in_use) {
@@ -323,7 +323,7 @@ Redis.prototype.close = function () {
 				try {
 					connection.close();
 				} catch (e) {
-					this.logger('error', '关闭连接失败:', e);
+					this.log('error', '关闭连接失败:', e);
 				}
 			}
 			this.connection_pool.in_use.clear();
@@ -340,20 +340,20 @@ Redis.prototype.close = function () {
 						// 某些Redis客户端可能使用end方法
 						connection.end();
 					} else {
-						this.logger('debug', '连接对象没有可用的关闭方法');
+						this.log('debug', '连接对象没有可用的关闭方法');
 					}
 				} catch (e) {
-					this.logger('error', '关闭连接失败:', e);
+					this.log('error', '关闭连接失败:', e);
 				}
 			}
 			this.connection_pool.available = [];
 		}
 
 		this.connected = false;
-		this.logger('debug', 'Redis连接已断开');
+		this.log('debug', 'Redis连接已断开');
 		return Promise.resolve(true);
 	} catch (error) {
-		this.logger('error', '关闭连接时发生错误:', error);
+		this.log('error', '关闭连接时发生错误:', error);
 		return Promise.resolve(false);
 	}
 };
@@ -480,7 +480,7 @@ Redis.prototype.pipeline = function () {
 						// 直接返回结果值，符合测试期望的格式
 						results.push(result);
 					} catch (err) {
-						this.logger('error', `Pipeline命令执行失败 [${cmd[0]}]:`, err);
+						this.log('error', `Pipeline命令执行失败 [${cmd[0]}]:`, err);
 						results.push(null);
 					}
 				}
@@ -489,7 +489,7 @@ Redis.prototype.pipeline = function () {
 				redisInstance._recycleConnection(connection);
 				return results;
 			} catch (error) {
-				this.logger('error', 'Pipeline执行失败:', error);
+				this.log('error', 'Pipeline执行失败:', error);
 				return [];
 			}
 		}
@@ -536,7 +536,7 @@ Redis.prototype.ttl = async function (key, seconds) {
 					await connection.execute('EXPIRE', [key, seconds]);
 					return true;
 				} else {
-					this.logger('error', '连接对象不支持expire操作');
+					this.log('error', '连接对象不支持expire操作');
 					return false;
 				}
 			}
@@ -547,14 +547,14 @@ Redis.prototype.ttl = async function (key, seconds) {
 			} else if (typeof connection.execute === 'function') {
 				return await connection.execute('TTL', [key]);
 			} else {
-				this.logger('error', '连接对象不支持ttl操作');
+				this.log('error', '连接对象不支持ttl操作');
 				return -2; // 默认返回键不存在
 			}
 		} finally {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error', `${seconds !== undefined ? '设置' : '获取'}过期时间失败 [${key}]:`, err);
+		this.log('error', `${seconds !== undefined ? '设置' : '获取'}过期时间失败 [${key}]:`, err);
 		return seconds !== undefined ? false : -2;
 	}
 };
@@ -588,7 +588,7 @@ Redis.prototype.addInt = async function (key, num, seconds = 0) {
 
 		// 如果事件处理器标记为取消，则返回false
 		if (ctx.cancel) {
-			this.logger('debug', `addInt操作被事件处理器取消 [${key}]`);
+			this.log('debug', `addInt操作被事件处理器取消 [${key}]`);
 			return false;
 		}
 
@@ -611,7 +611,7 @@ Redis.prototype.addInt = async function (key, num, seconds = 0) {
 					result = await connection.execute('INCRBY', [prefixedKey, finalNum]);
 				} else {
 					// 如果出错，回退到先获取再设置的方式
-					this.logger('warn', `使用原子操作增加整数值失败，使用回退方案 [${key}]`);
+					this.log('warn', `使用原子操作增加整数值失败，使用回退方案 [${key}]`);
 					let value = await this.get(prefixedKey);
 					let n = 0;
 					if (value) {
@@ -629,7 +629,7 @@ Redis.prototype.addInt = async function (key, num, seconds = 0) {
 					result = await connection.execute('DECRBY', [prefixedKey, -finalNum]);
 				} else {
 					// 如果出错，回退到先获取再设置的方式
-					this.logger('warn', `使用原子操作减少整数值失败，使用回退方案`);
+					this.log('warn', `使用原子操作减少整数值失败，使用回退方案`);
 					let value = await this.get(prefixedKey);
 					let n = 0;
 					if (value) {
@@ -670,7 +670,7 @@ Redis.prototype.addInt = async function (key, num, seconds = 0) {
 			seconds,
 			error: err
 		});
-		this.logger('error', `增加整数值失败 [${key}]:`, err);
+		this.log('error', `增加整数值失败 [${key}]:`, err);
 		// 与CacheBase保持一致，错误时返回默认值而不是抛出异常
 		return 0;
 	}
@@ -708,7 +708,7 @@ Redis.prototype.addFloat = async function (key, num, seconds = 0) {
 
 		// 如果事件处理器标记为取消，则返回默认值
 		if (ctx.cancel) {
-			this.logger('debug', `addFloat操作被事件处理器取消 [${key}]`);
+			this.log('debug', `addFloat操作被事件处理器取消 [${key}]`);
 			return 0;
 		}
 
@@ -734,7 +734,7 @@ Redis.prototype.addFloat = async function (key, num, seconds = 0) {
 			}
 			// 回退方案
 			else {
-				this.logger('warn', `连接对象不支持incrByFloat操作，使用回退方案`);
+				this.log('warn', `连接对象不支持incrByFloat操作，使用回退方案`);
 				let value = await this.get(prefixedKey);
 				let n = 0;
 				if (value) {
@@ -765,7 +765,7 @@ Redis.prototype.addFloat = async function (key, num, seconds = 0) {
 			return result;
 		} catch (err) {
 			// 如果出错，回退到先获取再设置的方式
-			this.logger('warn', `使用原子操作增加浮点数值失败，使用回退方案:`, err);
+			this.log('warn', `使用原子操作增加浮点数值失败，使用回退方案:`, err);
 			let value = await this.get(prefixedKey);
 			let n = 0;
 			if (value) {
@@ -794,7 +794,7 @@ Redis.prototype.addFloat = async function (key, num, seconds = 0) {
 			seconds,
 			error: err
 		});
-		this.logger('error', `增加浮点数值失败 [${key}]:`, err);
+		this.log('error', `增加浮点数值失败 [${key}]:`, err);
 		// 与CacheBase保持一致，错误时返回默认值而不是抛出异常
 		return 0;
 	}
@@ -831,7 +831,7 @@ Redis.prototype.addStr = async function (key, str, seconds = 0) {
 
 		// 如果事件处理器标记为取消，则返回0
 		if (ctx.cancel) {
-			this.logger('debug', `addStr操作被事件处理器取消 [${key}]`);
+			this.log('debug', `addStr操作被事件处理器取消 [${key}]`);
 			return 0;
 		}
 
@@ -857,7 +857,7 @@ Redis.prototype.addStr = async function (key, str, seconds = 0) {
 			}
 			// 回退方案
 			else {
-				this.logger('warn', `连接对象不支持append操作，使用回退方案`);
+				this.log('warn', `连接对象不支持append操作，使用回退方案`);
 				let value = await this.get(prefixedKey) || '';
 				value += finalStr;
 				await this.set(prefixedKey, value, finalSeconds);
@@ -883,7 +883,7 @@ Redis.prototype.addStr = async function (key, str, seconds = 0) {
 			});
 			return result;
 		} catch (err) {
-			this.logger('warn', '追加字符串失败:', err);
+			this.log('warn', '追加字符串失败:', err);
 			// 回退方案：先获取再设置
 			let value = await this.get(prefixedKey) || '';
 			value += finalStr;
@@ -909,7 +909,7 @@ Redis.prototype.addStr = async function (key, str, seconds = 0) {
 			seconds,
 			error: err
 		});
-		this.logger('error', `追加字符串失败 [${key}]:`, err);
+		this.log('error', `追加字符串失败 [${key}]:`, err);
 		return 0;
 	}
 };
@@ -952,7 +952,7 @@ Redis.prototype.del = async function (key) {
 
 		// 如果事件处理器标记为取消，则返回false
 		if (ctx.cancel) {
-			this.logger('debug', `del操作被事件处理器取消 [${key}]`);
+			this.log('debug', `del操作被事件处理器取消 [${key}]`);
 			return false;
 		}
 
@@ -1005,7 +1005,7 @@ Redis.prototype.del = async function (key) {
 			key,
 			error: err
 		});
-		this.logger('error', `删除缓存失败 [${key}]:`, err);
+		this.log('error', `删除缓存失败 [${key}]:`, err);
 		return false;
 	}
 };
@@ -1042,7 +1042,7 @@ Redis.prototype.set = async function (key, value, seconds = 0) {
 
 		// 如果事件处理器标记为取消，则返回false
 		if (ctx.cancel) {
-			this.logger('debug', `set操作被事件处理器取消 [${key}]`);
+			this.log('debug', `set操作被事件处理器取消 [${key}]`);
 			return false;
 		}
 
@@ -1080,7 +1080,7 @@ Redis.prototype.set = async function (key, value, seconds = 0) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error', `设置缓存失败 [${key}]:`, err);
+		this.log('error', `设置缓存失败 [${key}]:`, err);
 		// 触发错误事件
 		this.emit('set:error', {
 			key,
@@ -1120,7 +1120,7 @@ Redis.prototype.add = async function (key, value, seconds) {
 
 		// 如果事件处理器标记为取消，则返回false
 		if (ctx.cancel) {
-			this.logger('debug', `add操作被事件处理器取消 [${key}]`);
+			this.log('debug', `add操作被事件处理器取消 [${key}]`);
 			return false;
 		}
 
@@ -1160,7 +1160,7 @@ Redis.prototype.add = async function (key, value, seconds) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error', `添加缓存失败 [${key}]:`, err);
+		this.log('error', `添加缓存失败 [${key}]:`, err);
 		// 触发错误事件
 		this.emit('add:error', {
 			key,
@@ -1198,7 +1198,7 @@ Redis.prototype.get = async function (key) {
 
 		// 如果事件处理器标记为取消，则返回null
 		if (ctx.cancel) {
-			this.logger('debug', `get操作被事件处理器取消 [${key}]`);
+			this.log('debug', `get操作被事件处理器取消 [${key}]`);
 			return null;
 		}
 
@@ -1239,7 +1239,7 @@ Redis.prototype.get = async function (key) {
 			key,
 			error: err
 		});
-		this.logger('error', `获取缓存失败 [${key}]:`, err);
+		this.log('error', `获取缓存失败 [${key}]:`, err);
 		return null;
 	}
 };
@@ -1265,7 +1265,7 @@ Redis.prototype.has = async function (key) {
 
 		// 如果事件处理器标记为取消，则返回false
 		if (ctx.cancel) {
-			this.logger('debug', `has操作被事件处理器取消 [${key}]`);
+			this.log('debug', `has操作被事件处理器取消 [${key}]`);
 			return false;
 		}
 
@@ -1295,7 +1295,7 @@ Redis.prototype.has = async function (key) {
 			key,
 			error: err
 		});
-		this.logger('error', `检查键是否存在失败 [${key}]:`, err);
+		this.log('error', `检查键是否存在失败 [${key}]:`, err);
 		return false;
 	}
 };
@@ -1338,7 +1338,7 @@ Redis.prototype.exists = async function (key) {
 
 		// 如果事件处理器标记为取消，则返回0
 		if (ctx.cancel) {
-			this.logger('debug', `exists操作被事件处理器取消 [${key}]`);
+			this.log('debug', `exists操作被事件处理器取消 [${key}]`);
 			return 0;
 		}
 
@@ -1373,7 +1373,7 @@ Redis.prototype.exists = async function (key) {
 			key,
 			error: err
 		});
-		this.logger('error', `检查键存在性失败 [${key}]:`, err);
+		this.log('error', `检查键存在性失败 [${key}]:`, err);
 		return 0;
 	}
 };
@@ -1392,7 +1392,7 @@ Redis.prototype.getrange = async function (key, start, end) {
 			key = this._addPrefix(key);
 			return await connection.getRange(key, start, end);
 		} catch (err) {
-			this.logger('error', '获取字符串范围失败:', err);
+			this.log('error', '获取字符串范围失败:', err);
 			// 回退方案
 			const value = await this.get(key);
 			if (value && typeof value === 'string') {
@@ -1403,7 +1403,7 @@ Redis.prototype.getrange = async function (key, start, end) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error', `获取字符串范围失败 [${key}]:`, err);
+		this.log('error', `获取字符串范围失败 [${key}]:`, err);
 		return '';
 	}
 };
@@ -1439,7 +1439,7 @@ Redis.prototype.setrange = async function (key, index, value) {
 
 		// 如果事件处理器标记为取消，则返回0
 		if (ctx.cancel) {
-			this.logger('debug', `setrange操作被事件处理器取消 [${key}]`);
+			this.log('debug', `setrange操作被事件处理器取消 [${key}]`);
 			return 0;
 		}
 
@@ -1465,7 +1465,7 @@ Redis.prototype.setrange = async function (key, index, value) {
 			}
 			// 回退方案
 			else {
-				this.logger('warn', `连接对象不支持setRange操作，使用回退方案`);
+				this.log('warn', `连接对象不支持setRange操作，使用回退方案`);
 				let str = await this.get(finalKey) || '';
 				if (str.length < finalIndex) {
 					// 填充空格到指定索引
@@ -1486,7 +1486,7 @@ Redis.prototype.setrange = async function (key, index, value) {
 			});
 			return result;
 		} catch (err) {
-			this.logger('error', '设置字符串范围失败:', err);
+			this.log('error', '设置字符串范围失败:', err);
 			// 回退方案
 			let str = await this.get(finalKey) || '';
 			if (str.length < finalIndex) {
@@ -1516,7 +1516,7 @@ Redis.prototype.setrange = async function (key, index, value) {
 			value,
 			error: err
 		});
-		this.logger('error', `设置字符串范围失败 [${key}]:`, err);
+		this.log('error', `设置字符串范围失败 [${key}]:`, err);
 		return 0;
 	}
 };
@@ -1537,7 +1537,7 @@ Redis.prototype.clear = async function (key) {
 
 		// 如果事件处理器标记为取消，则返回false
 		if (ctx.cancel) {
-			this.logger('debug', `clear操作被事件处理器取消`);
+			this.log('debug', `clear操作被事件处理器取消`);
 			return false;
 		}
 
@@ -1561,7 +1561,7 @@ Redis.prototype.clear = async function (key) {
 					await connection.execute('FLUSHDB');
 					success = true;
 				} else {
-					this.logger('error', '连接对象不支持flushDb操作');
+					this.log('error', '连接对象不支持flushDb操作');
 					success = false;
 				}
 			}
@@ -1581,7 +1581,7 @@ Redis.prototype.clear = async function (key) {
 			key,
 			error: err
 		});
-		this.logger('error', '清空缓存失败:', err);
+		this.log('error', '清空缓存失败:', err);
 		return false;
 	}
 };
@@ -1625,7 +1625,7 @@ Redis.prototype.sort = async function (key, options = {}) {
 
 			return await connection.sort(key, sortOptions);
 		} catch (err) {
-			this.logger('error', '排序失败:', err);
+			this.log('error', '排序失败:', err);
 			// 回退方案：获取数据后在内存中排序
 			const data = await this.getForList(key);
 			return data.sort((a, b) => {
@@ -1639,7 +1639,7 @@ Redis.prototype.sort = async function (key, options = {}) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error', `排序失败 [${key}]:`, err);
+		this.log('error', `排序失败 [${key}]:`, err);
 		return [];
 	}
 };
@@ -1662,7 +1662,7 @@ Redis.prototype.keys = async function (pattern = '*') {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error', '获取键列表失败:', err);
+		this.log('error', '获取键列表失败:', err);
 		return [];
 	}
 };
@@ -1687,7 +1687,7 @@ Redis.prototype.setForList = async function (key, value, seconds) {
 
 		// 如果事件处理器标记为取消，则返回0
 		if (ctx.cancel) {
-			this.logger('debug', `setForList操作被事件处理器取消 [${key}]`);
+			this.log('debug', `setForList操作被事件处理器取消 [${key}]`);
 			return 0;
 		}
 
@@ -1717,7 +1717,7 @@ Redis.prototype.setForList = async function (key, value, seconds) {
 					} else if (typeof connection.execute === 'function') {
 						len = await connection.execute('RPUSH', [finalKey, ...finalValue]);
 					} else {
-						this.logger('error', '连接对象不支持rPush操作');
+						this.log('error', '连接对象不支持rPush操作');
 						len = 0;
 					}
 				}
@@ -1728,7 +1728,7 @@ Redis.prototype.setForList = async function (key, value, seconds) {
 				} else if (typeof connection.execute === 'function') {
 					len = await connection.execute('RPUSH', [finalKey, finalValue]);
 				} else {
-					this.logger('error', '连接对象不支持rPush操作');
+					this.log('error', '连接对象不支持rPush操作');
 					len = 0;
 				}
 			}
@@ -1739,7 +1739,7 @@ Redis.prototype.setForList = async function (key, value, seconds) {
 				} else if (typeof connection.execute === 'function') {
 					await connection.execute('EXPIRE', [finalKey, finalSeconds]);
 				} else {
-					this.logger('error', '连接对象不支持expire操作');
+					this.log('error', '连接对象不支持expire操作');
 				}
 			}
 
@@ -1762,7 +1762,7 @@ Redis.prototype.setForList = async function (key, value, seconds) {
 			value,
 			error: err
 		});
-		this.logger('error', `设置列表失败 [${key}]:`, err);
+		this.log('error', `设置列表失败 [${key}]:`, err);
 		return 0;
 	}
 };
@@ -1787,7 +1787,7 @@ Redis.prototype.addForList = async function (key, value, seconds = 0) {
 
 		// 如果事件处理器标记为取消，则返回0
 		if (ctx.cancel) {
-			this.logger('debug', `addForList操作被事件处理器取消 [${key}]`);
+			this.log('debug', `addForList操作被事件处理器取消 [${key}]`);
 			return 0;
 		}
 
@@ -1811,7 +1811,7 @@ Redis.prototype.addForList = async function (key, value, seconds = 0) {
 					} else if (typeof connection.execute === 'function') {
 						len = await connection.execute('RPUSH', [finalKey, ...finalValue]);
 					} else {
-						this.logger('error', '连接对象不支持rPush操作');
+						this.log('error', '连接对象不支持rPush操作');
 						len = 0;
 					}
 				}
@@ -1822,7 +1822,7 @@ Redis.prototype.addForList = async function (key, value, seconds = 0) {
 				} else if (typeof connection.execute === 'function') {
 					len = await connection.execute('RPUSH', [finalKey, finalValue]);
 				} else {
-					this.logger('error', '连接对象不支持rPush操作');
+					this.log('error', '连接对象不支持rPush操作');
 					len = 0;
 				}
 			}
@@ -1833,7 +1833,7 @@ Redis.prototype.addForList = async function (key, value, seconds = 0) {
 				} else if (typeof connection.execute === 'function') {
 					await connection.execute('EXPIRE', [finalKey, finalSeconds]);
 				} else {
-					this.logger('error', '连接对象不支持expire操作');
+					this.log('error', '连接对象不支持expire操作');
 				}
 			}
 
@@ -1856,7 +1856,7 @@ Redis.prototype.addForList = async function (key, value, seconds = 0) {
 			value,
 			error: err
 		});
-		this.logger('error', `添加列表项失败 [${key}]:`, err);
+		this.log('error', `添加列表项失败 [${key}]:`, err);
 		return 0;
 	}
 };
@@ -1884,7 +1884,7 @@ Redis.prototype.hasForList = async function (key, value) {
 			return itemStr === valueStr || item === value;
 		});
 	} catch (err) {
-		this.logger('error', `检查列表成员是否存在失败 [${key}]:`, err);
+		this.log('error', `检查列表成员是否存在失败 [${key}]:`, err);
 		return false;
 	}
 };
@@ -1909,7 +1909,7 @@ Redis.prototype.getForList = async function (key, start = 0, end = -1) {
 
 		// 如果事件处理器标记为取消，则返回空数组
 		if (ctx.cancel) {
-			this.logger('debug', `getForList操作被事件处理器取消 [${key}]`);
+			this.log('debug', `getForList操作被事件处理器取消 [${key}]`);
 			return [];
 		}
 
@@ -1934,12 +1934,12 @@ Redis.prototype.getForList = async function (key, start = 0, end = -1) {
 				// 回退到通用execute方法
 				result = await connection.execute('LRANGE', [finalKey, finalStart, finalEnd]);
 			} else {
-				this.logger('error', '连接对象不支持lRange或lrange操作');
+				this.log('error', '连接对象不支持lRange或lrange操作');
 				return [];
 			}
 			// 确保结果是数组
 			if (!Array.isArray(result)) {
-				this.logger('error', '列表查询结果不是数组格式');
+				this.log('error', '列表查询结果不是数组格式');
 				return [];
 			}
 
@@ -1979,7 +1979,7 @@ Redis.prototype.getForList = async function (key, start = 0, end = -1) {
 			end,
 			error: err
 		});
-		this.logger('error', `获取列表失败 [${key}]:`, err);
+		this.log('error', `获取列表失败 [${key}]:`, err);
 		return [];
 	}
 };
@@ -2004,7 +2004,7 @@ Redis.prototype.clearForList = async function (key) {
 
 		// 如果事件处理器标记为取消，则返回false
 		if (ctx.cancel) {
-			this.logger('debug', `clearForList操作被事件处理器取消 [${key}]`);
+			this.log('debug', `clearForList操作被事件处理器取消 [${key}]`);
 			return false;
 		}
 
@@ -2028,7 +2028,7 @@ Redis.prototype.clearForList = async function (key) {
 			key,
 			error: err
 		});
-		this.logger('error', `清空列表失败 [${key}]:`, err);
+		this.log('error', `清空列表失败 [${key}]:`, err);
 		return false;
 	}
 };
@@ -2066,7 +2066,7 @@ Redis.prototype.mget = async function (keys) {
 
 		// 如果事件处理器标记为取消，则返回空数组
 		if (ctx.cancel) {
-			this.logger('debug', `mget操作被事件处理器取消 [${keys}]`);
+			this.log('debug', `mget操作被事件处理器取消 [${keys}]`);
 			return [];
 		}
 
@@ -2112,7 +2112,7 @@ Redis.prototype.mget = async function (keys) {
 			keys,
 			error: err
 		});
-		this.logger('error', `批量获取缓存失败 [${keys}]:`, err);
+		this.log('error', `批量获取缓存失败 [${keys}]:`, err);
 		return [];
 	}
 }
@@ -2135,7 +2135,7 @@ Redis.prototype.mset = async function (obj, seconds = 0) {
 
 		// 如果事件处理器标记为取消，则返回false
 		if (ctx.cancel) {
-			this.logger('debug', `mset操作被事件处理器取消`);
+			this.log('debug', `mset操作被事件处理器取消`);
 			return false;
 		}
 
@@ -2181,7 +2181,7 @@ Redis.prototype.mset = async function (obj, seconds = 0) {
 		});
 
 		// 如果Pipeline失败，回退到原实现
-		this.logger('warn', '使用Pipeline批量设置失败，使用回退方案:', err);
+		this.log('warn', '使用Pipeline批量设置失败，使用回退方案:', err);
 		const connection = await this._getConnection();
 		try {
 			const pairs = [];
@@ -2219,7 +2219,7 @@ Redis.prototype.mset = async function (obj, seconds = 0) {
 				seconds,
 				error: fallbackErr
 			});
-			this.logger('error', '回退方案批量设置也失败:', fallbackErr);
+			this.log('error', '回退方案批量设置也失败:', fallbackErr);
 			return false;
 		} finally {
 			this._recycleConnection(connection);
@@ -2250,7 +2250,7 @@ Redis.prototype.hdel = async function (key, fields) {
 
 		// 如果事件处理器标记为取消，则返回false
 		if (ctx.cancel) {
-			this.logger('debug', `hdel操作被事件处理器取消 [${key}]`);
+			this.log('debug', `hdel操作被事件处理器取消 [${key}]`);
 			return false;
 		}
 
@@ -2275,7 +2275,7 @@ Redis.prototype.hdel = async function (key, fields) {
 			} else if (typeof connection.execute === 'function') {
 				deletedCount = await connection.execute('HDEL', [finalKey, ...finalFields]);
 			} else {
-				this.logger('error', '连接对象不支持hDel操作');
+				this.log('error', '连接对象不支持hDel操作');
 				deletedCount = 0;
 			}
 
@@ -2296,7 +2296,7 @@ Redis.prototype.hdel = async function (key, fields) {
 			value: fields,
 			error: err
 		});
-		this.logger('error', `删除哈希字段失败 [${key}]:`, err);
+		this.log('error', `删除哈希字段失败 [${key}]:`, err);
 		return 0; // 与Redis语义保持一致，返回删除的字段数量
 	}
 };
@@ -2316,7 +2316,7 @@ Redis.prototype.hlen = async function (key) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error', `获取哈希字段数量失败 [${key}]:`, err);
+		this.log('error', `获取哈希字段数量失败 [${key}]:`, err);
 		return 0;
 	}
 };
@@ -2430,7 +2430,7 @@ class RedisPipeline {
 			// 处理结果（解析JSON等）
 			return results.map(([err, value], index) => {
 				if (err) {
-					this.logger('error', `[Pipeline] Pipeline命令执行失败 [${this.commands[index].name}]:`, err);
+					this.log('error', `[Pipeline] Pipeline命令执行失败 [${this.commands[index].name}]:`, err);
 					return null;
 				}
 
@@ -2470,7 +2470,7 @@ Redis.prototype.clearExpire = async function () {
 		this.emit('clearExpire:error', {
 			error: err
 		});
-		this.logger('error', '清空过期数据失败:', err);
+		this.log('error', '清空过期数据失败:', err);
 		return false;
 	}
 };
@@ -2499,14 +2499,14 @@ Redis.prototype._getConnection = function () {
 			} else {
 				// 否则等待连接释放
 				// 这里简化处理，直接创建连接（生产环境应实现等待队列）
-				this.logger('warn', '连接池已满，创建额外连接');
+				this.log('warn', '连接池已满，创建额外连接');
 				this._createConnection().then(connection => {
 					this.connection_pool.in_use.add(connection);
 					resolve(connection);
 				}).catch(reject);
 			}
 		} catch (error) {
-			this.logger('error', '获取连接失败:', error);
+			this.log('error', '获取连接失败:', error);
 			reject(error);
 		}
 	});
@@ -2529,15 +2529,15 @@ Redis.prototype._releaseConnection = function (connection) {
 					} else if (typeof connection.end === 'function') {
 						connection.end();
 					} else {
-						this.logger('debug', '连接对象没有可用的关闭方法');
+						this.log('debug', '连接对象没有可用的关闭方法');
 					}
 				} catch (e) {
-					this.logger('error', '关闭多余连接失败:', e);
+					this.log('error', '关闭多余连接失败:', e);
 				}
 			}
 		}
 	} catch (error) {
-		this.logger('error', '释放连接失败:', error);
+		this.log('error', '释放连接失败:', error);
 	}
 };
 
@@ -2566,7 +2566,7 @@ Redis.prototype.hset = async function (key, field, value) {
 
 		// 如果事件处理器标记为取消，则返回false
 		if (ctx.cancel) {
-			this.logger('debug', `hset操作被事件处理器取消 [${key}:${field}]`);
+			this.log('debug', `hset操作被事件处理器取消 [${key}:${field}]`);
 			return false;
 		}
 
@@ -2599,7 +2599,7 @@ Redis.prototype.hset = async function (key, field, value) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error', `设置哈希字段失败 [${key}:${field}]:`, err);
+		this.log('error', `设置哈希字段失败 [${key}:${field}]:`, err);
 		// 触发错误事件
 		this.emit('hset:error', {
 			key,
@@ -2641,7 +2641,7 @@ Redis.prototype.hget = async function (key, field) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error', `获取哈希字段失败 [${key}:${field}]:`, err);
+		this.log('error', `获取哈希字段失败 [${key}:${field}]:`, err);
 		return null;
 	}
 };
@@ -2664,7 +2664,7 @@ Redis.prototype.hmset = async function (key, obj) {
 
 		// 如果事件处理器标记为取消，则返回false
 		if (ctx.cancel) {
-			this.logger('debug', `hmset操作被事件处理器取消 [${key}]`);
+			this.log('debug', `hmset操作被事件处理器取消 [${key}]`);
 			return false;
 		}
 
@@ -2679,20 +2679,20 @@ Redis.prototype.hmset = async function (key, obj) {
 			finalKey = this._addPrefix(finalKey);
 
 			// 检查Redis版本，支持不同的方法
-			this.logger('debug',
+			this.log('debug',
 				`hmset方法检测到连接对象方法: hSet=${typeof connection.hSet === 'function'}, hmset=${typeof connection.hmset === 'function'}`
 			);
 			let success = true;
 
 			// 优化策略：对所有Redis版本都使用逐个字段设置的方式，确保兼容性和正确性
-			this.logger('debug', `对键 ${finalKey} 强制使用逐个字段设置策略`);
+			this.log('debug', `对键 ${finalKey} 强制使用逐个字段设置策略`);
 
 			// 获取适合的设置字段方法
 			const setFieldMethod = typeof connection.hSet === 'function' ? 'hSet' :
 				typeof connection.hset === 'function' ? 'hset' : null;
 
 			if (!setFieldMethod) {
-				this.logger('error', `连接对象不支持hSet或hset操作`);
+				this.log('error', `连接对象不支持hSet或hset操作`);
 				return false;
 			}
 
@@ -2704,10 +2704,10 @@ Redis.prototype.hmset = async function (key, obj) {
 						if (typeof value !== 'string') {
 							value = JSON.stringify(value);
 						}
-						this.logger('debug', `单独设置字段: ${setFieldMethod}(${finalKey}, ${field}, ${value})`);
+						this.log('debug', `单独设置字段: ${setFieldMethod}(${finalKey}, ${field}, ${value})`);
 						await connection[setFieldMethod](finalKey, field, value);
 					} catch (singleError) {
-						this.logger('error', `设置单个字段失败 ${field}: ${singleError.message}`);
+						this.log('error', `设置单个字段失败 ${field}: ${singleError.message}`);
 						success = false;
 						break;
 					}
@@ -2716,19 +2716,19 @@ Redis.prototype.hmset = async function (key, obj) {
 
 			// 验证所有字段是否都设置成功
 			if (success) {
-				this.logger('debug', `验证所有字段设置情况`);
+				this.log('debug', `验证所有字段设置情况`);
 				for (const field in finalObj) {
 					if (finalObj.hasOwnProperty(field)) {
 						try {
 							const hgetMethod = typeof connection.hGet === 'function' ? 'hGet' : 'hget';
 							const value = await connection[hgetMethod](finalKey, field);
-							this.logger('debug', `验证字段 ${field}: ${value !== null ? '存在' : '不存在'}`);
+							this.log('debug', `验证字段 ${field}: ${value !== null ? '存在' : '不存在'}`);
 							// 如果字段不存在，更新success状态
 							if (value === null) {
 								success = false;
 							}
 						} catch (getError) {
-							this.logger('error', `验证字段失败 ${field}: ${getError.message}`);
+							this.log('error', `验证字段失败 ${field}: ${getError.message}`);
 							success = false;
 						}
 					}
@@ -2746,7 +2746,7 @@ Redis.prototype.hmset = async function (key, obj) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error', `批量设置哈希字段失败 [${key}]:`, err);
+		this.log('error', `批量设置哈希字段失败 [${key}]:`, err);
 		// 触发错误事件
 		this.emit('hmset:error', {
 			key,
@@ -2771,14 +2771,14 @@ Redis.prototype.hgetall = async function (key) {
 				const result = await connection.hGetAll(key);
 				return result;
 			} else {
-				this.logger('error', '连接对象不支持hGetAll操作');
+				this.log('error', '连接对象不支持hGetAll操作');
 				return {};
 			}
 		} finally {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error', `获取哈希所有字段和值失败 [${key}]:`, err);
+		this.log('error', `获取哈希所有字段和值失败 [${key}]:`, err);
 		return {};
 	}
 };
@@ -2828,8 +2828,8 @@ Redis.prototype.hmget = async function (key, fields) {
 				});
 				return finalResult;
 			} else {
-				this.logger('error', '连接对象不支持hmGet操作');
-				this.logger('error', '错误: Redis客户端不支持hmget操作');
+				this.log('error', '连接对象不支持hmGet操作');
+				this.log('error', '错误: Redis客户端不支持hmget操作');
 				// 返回与fields长度相同的undefined数组，保持与注释一致
 				return fields.map(() => undefined);
 			}
@@ -2842,7 +2842,7 @@ Redis.prototype.hmget = async function (key, fields) {
 			fields,
 			error: err
 		});
-		this.logger('error', `哈希表批量获取失败 [${key}]:`, err);
+		this.log('error', `哈希表批量获取失败 [${key}]:`, err);
 		// 返回与fields长度相同的undefined数组，保持与注释类型一致
 		return fields.map(() => undefined);
 	}
@@ -2864,7 +2864,7 @@ Redis.prototype.expire = async function (key, seconds) {
 		this.emit('expire:before', ctx);
 
 		if (ctx.cancel) {
-			this.logger('debug', `expire操作被事件处理器取消 [${key}]`);
+			this.log('debug', `expire操作被事件处理器取消 [${key}]`);
 			return false;
 		}
 
@@ -2886,7 +2886,7 @@ Redis.prototype.expire = async function (key, seconds) {
 			});
 			return result === 1;
 		} catch (err) {
-			this.logger('error', `设置过期时间失败 [${finalKey}]:`, err);
+			this.log('error', `设置过期时间失败 [${finalKey}]:`, err);
 			this.emit('expire:error', {
 				key: finalKey,
 				ttl: finalSeconds,
@@ -2897,7 +2897,7 @@ Redis.prototype.expire = async function (key, seconds) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error', `设置过期时间失败 [${key}]:`, err);
+		this.log('error', `设置过期时间失败 [${key}]:`, err);
 		this.emit('expire:error', {
 			key,
 			ttl: seconds,
@@ -2932,7 +2932,7 @@ Redis.prototype.pexpire = async function (key, milliseconds) {
 		this.emit('pexpire:before', ctx);
 
 		if (ctx.cancel) {
-			this.logger('debug', `pexpire操作被事件处理器取消 [${key}]`);
+			this.log('debug', `pexpire操作被事件处理器取消 [${key}]`);
 			return false;
 		}
 
@@ -2950,7 +2950,7 @@ Redis.prototype.pexpire = async function (key, milliseconds) {
 			} else if (typeof connection.execute === 'function') {
 				result = await connection.execute('PEXPIRE', [this._addPrefix(finalKey), finalMilliseconds]);
 			} else {
-				this.logger('error', '连接对象不支持pexpire操作');
+				this.log('error', '连接对象不支持pexpire操作');
 				return false;
 			}
 
@@ -2962,7 +2962,7 @@ Redis.prototype.pexpire = async function (key, milliseconds) {
 			});
 			return result === 1;
 		} catch (err) {
-			this.logger('error', `设置过期时间（毫秒）失败 [${finalKey}]:`, err);
+			this.log('error', `设置过期时间（毫秒）失败 [${finalKey}]:`, err);
 			this.emit('pexpire:error', {
 				key: finalKey,
 				ttl: finalMilliseconds,
@@ -2973,7 +2973,7 @@ Redis.prototype.pexpire = async function (key, milliseconds) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error', `设置过期时间（毫秒）失败 [${key}]:`, err);
+		this.log('error', `设置过期时间（毫秒）失败 [${key}]:`, err);
 		this.emit('pexpire:error', {
 			key,
 			ttl: milliseconds,
@@ -2994,7 +2994,7 @@ Redis.prototype.persist = async function (key) {
 		this.emit('persist:before', ctx);
 
 		if (ctx.cancel) {
-			this.logger('debug', `persist操作被事件处理器取消 [${key}]`);
+			this.log('debug', `persist操作被事件处理器取消 [${key}]`);
 			return false;
 		}
 
@@ -3014,7 +3014,7 @@ Redis.prototype.persist = async function (key) {
 			});
 			return result === 1;
 		} catch (err) {
-			this.logger('error', `移除过期时间失败 [${finalKey}]:`, err);
+			this.log('error', `移除过期时间失败 [${finalKey}]:`, err);
 			this.emit('persist:error', {
 				key: finalKey,
 				error: err
@@ -3024,7 +3024,7 @@ Redis.prototype.persist = async function (key) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error', `移除过期时间失败 [${key}]:`, err);
+		this.log('error', `移除过期时间失败 [${key}]:`, err);
 		this.emit('persist:error', {
 			key,
 			error: err
@@ -3055,7 +3055,7 @@ Redis.prototype.incr = async function (key, seconds = 0) {
 		this.emit('incr:before', ctx);
 
 		if (ctx.cancel) {
-			this.logger('debug', `incr操作被事件处理器取消 [${key}]`);
+			this.log('debug', `incr操作被事件处理器取消 [${key}]`);
 			return null;
 		}
 
@@ -3086,7 +3086,7 @@ Redis.prototype.incr = async function (key, seconds = 0) {
 			});
 			return result;
 		} catch (err) {
-			this.logger('error', `增加整数值失败 [${finalKey}]:`, err);
+			this.log('error', `增加整数值失败 [${finalKey}]:`, err);
 			this.emit('incr:error', {
 				key: finalKey,
 				seconds: finalSeconds,
@@ -3097,7 +3097,7 @@ Redis.prototype.incr = async function (key, seconds = 0) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error', `增加整数值失败 [${key}]:`, err);
+		this.log('error', `增加整数值失败 [${key}]:`, err);
 		this.emit('incr:error', {
 			key,
 			seconds,
@@ -3129,7 +3129,7 @@ Redis.prototype.decr = async function (key, seconds = 0) {
 		this.emit('decr:before', ctx);
 
 		if (ctx.cancel) {
-			this.logger('debug', `decr操作被事件处理器取消 [${key}]`);
+			this.log('debug', `decr操作被事件处理器取消 [${key}]`);
 			return null;
 		}
 
@@ -3160,7 +3160,7 @@ Redis.prototype.decr = async function (key, seconds = 0) {
 			});
 			return result;
 		} catch (err) {
-			this.logger('error', `减少整数值失败 [${finalKey}]:`, err);
+			this.log('error', `减少整数值失败 [${finalKey}]:`, err);
 			this.emit('decr:error', {
 				key: finalKey,
 				seconds: finalSeconds,
@@ -3171,7 +3171,7 @@ Redis.prototype.decr = async function (key, seconds = 0) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error', `减少整数值失败 [${key}]:`, err);
+		this.log('error', `减少整数值失败 [${key}]:`, err);
 		this.emit('decr:error', {
 			key,
 			seconds,
@@ -3208,7 +3208,7 @@ Redis.prototype.incrbyfloat = async function (key, increment, seconds = 0) {
 		this.emit('incrbyfloat:before', ctx);
 
 		if (ctx.cancel) {
-			this.logger('debug', `incrbyfloat操作被事件处理器取消 [${key}]`);
+			this.log('debug', `incrbyfloat操作被事件处理器取消 [${key}]`);
 			return null;
 		}
 
@@ -3242,7 +3242,7 @@ Redis.prototype.incrbyfloat = async function (key, increment, seconds = 0) {
 			});
 			return parsedResult;
 		} catch (err) {
-			this.logger('error', `增加浮点数值失败 [${finalKey}]:`, err);
+			this.log('error', `增加浮点数值失败 [${finalKey}]:`, err);
 			this.emit('incrbyfloat:error', {
 				key: finalKey,
 				increment: finalIncrement,
@@ -3254,7 +3254,7 @@ Redis.prototype.incrbyfloat = async function (key, increment, seconds = 0) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error', `增加浮点数值失败 [${key}]:`, err);
+		this.log('error', `增加浮点数值失败 [${key}]:`, err);
 		this.emit('incrbyfloat:error', {
 			key,
 			increment,
@@ -3292,7 +3292,7 @@ Redis.prototype.incrby = async function (key, increment, seconds = 0) {
 		this.emit('incrby:before', ctx);
 
 		if (ctx.cancel) {
-			this.logger('debug', `incrby操作被事件处理器取消 [${key}]`);
+			this.log('debug', `incrby操作被事件处理器取消 [${key}]`);
 			return null;
 		}
 
@@ -3325,7 +3325,7 @@ Redis.prototype.incrby = async function (key, increment, seconds = 0) {
 			});
 			return result;
 		} catch (err) {
-			this.logger('error', `增加指定值失败 [${finalKey}]:`, err);
+			this.log('error', `增加指定值失败 [${finalKey}]:`, err);
 			this.emit('incrby:error', {
 				key: finalKey,
 				increment: finalIncrement,
@@ -3337,7 +3337,7 @@ Redis.prototype.incrby = async function (key, increment, seconds = 0) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error', `增加指定值失败 [${key}]:`, err);
+		this.log('error', `增加指定值失败 [${key}]:`, err);
 		this.emit('incrby:error', {
 			key,
 			increment,
@@ -3375,7 +3375,7 @@ Redis.prototype.decrby = async function (key, decrement, seconds = 0) {
 		this.emit('decrby:before', ctx);
 
 		if (ctx.cancel) {
-			this.logger('debug', `decrby操作被事件处理器取消 [${key}]`);
+			this.log('debug', `decrby操作被事件处理器取消 [${key}]`);
 			return null;
 		}
 
@@ -3408,7 +3408,7 @@ Redis.prototype.decrby = async function (key, decrement, seconds = 0) {
 			});
 			return result;
 		} catch (err) {
-			this.logger('error', `减少指定值失败 [${finalKey}]:`, err);
+			this.log('error', `减少指定值失败 [${finalKey}]:`, err);
 			this.emit('decrby:error', {
 				key: finalKey,
 				decrement: finalDecrement,
@@ -3420,7 +3420,7 @@ Redis.prototype.decrby = async function (key, decrement, seconds = 0) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error', `减少指定值失败 [${key}]:`, err);
+		this.log('error', `减少指定值失败 [${key}]:`, err);
 		this.emit('decrby:error', {
 			key,
 			decrement,
@@ -3450,7 +3450,7 @@ Redis.prototype.sadd = async function (key, members) {
 		this.emit('sadd:before', ctx);
 
 		if (ctx.cancel) {
-			this.logger('debug', `sadd操作被事件处理器取消 [${key}]`);
+			this.log('debug', `sadd操作被事件处理器取消 [${key}]`);
 			return 0;
 		}
 
@@ -3475,7 +3475,7 @@ Redis.prototype.sadd = async function (key, members) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error', `添加集合成员失败 [${key}]:`, err);
+		this.log('error', `添加集合成员失败 [${key}]:`, err);
 		this.emit('sadd:error', {
 			key,
 			members,
@@ -3502,7 +3502,7 @@ Redis.prototype.srem = async function (key, members) {
 		this.emit('srem:before', ctx);
 
 		if (ctx.cancel) {
-			this.logger('debug', `srem操作被事件处理器取消 [${key}]`);
+			this.log('debug', `srem操作被事件处理器取消 [${key}]`);
 			return 0;
 		}
 
@@ -3527,7 +3527,7 @@ Redis.prototype.srem = async function (key, members) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error', `移除集合成员失败 [${key}]:`, err);
+		this.log('error', `移除集合成员失败 [${key}]:`, err);
 		this.emit('srem:error', {
 			key,
 			members,
@@ -3578,7 +3578,7 @@ Redis.prototype.sismember = async function (key, member) {
 			member,
 			error: err
 		});
-		this.logger('error', `检查集合成员失败 [${key}:${member}]:`, err);
+		this.log('error', `检查集合成员失败 [${key}:${member}]:`, err);
 		return false;
 	}
 };
@@ -3603,7 +3603,7 @@ Redis.prototype.smembers = async function (key) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error', `获取集合所有成员失败 [${key}]:`, err);
+		this.log('error', `获取集合所有成员失败 [${key}]:`, err);
 		this.emit('smembers:error', {
 			key,
 			error: err
@@ -3628,7 +3628,7 @@ Redis.prototype.scard = async function (key) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error', `获取集合大小失败 [${key}]:`, err);
+		this.log('error', `获取集合大小失败 [${key}]:`, err);
 		return 0;
 	}
 };
@@ -3650,7 +3650,7 @@ Redis.prototype.sinter = async function (keys) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error', `获取集合交集失败:`, err);
+		this.log('error', `获取集合交集失败:`, err);
 		return [];
 	}
 };
@@ -3672,7 +3672,7 @@ Redis.prototype.sunion = async function (keys) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error', `获取集合并集失败:`, err);
+		this.log('error', `获取集合并集失败:`, err);
 		return [];
 	}
 };
@@ -3694,7 +3694,7 @@ Redis.prototype.sdiff = async function (keys) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error', `获取集合差集失败:`, err);
+		this.log('error', `获取集合差集失败:`, err);
 		return [];
 	}
 };
@@ -3720,7 +3720,7 @@ Redis.prototype.zadd = async function (key, score, member) {
 		this.emit('zadd:before', ctx);
 
 		if (ctx.cancel) {
-			this.logger('debug', `zadd操作被事件处理器取消 [${key}]`);
+			this.log('debug', `zadd操作被事件处理器取消 [${key}]`);
 			return false;
 		}
 
@@ -3750,7 +3750,7 @@ Redis.prototype.zadd = async function (key, score, member) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error', `添加有序集合成员失败 [${key}]:`, err);
+		this.log('error', `添加有序集合成员失败 [${key}]:`, err);
 		this.emit('zadd:error', {
 			key,
 			score,
@@ -3778,7 +3778,7 @@ Redis.prototype.zrem = async function (key, members) {
 		this.emit('zrem:before', ctx);
 
 		if (ctx.cancel) {
-			this.logger('debug', `zrem操作被事件处理器取消 [${key}]`);
+			this.log('debug', `zrem操作被事件处理器取消 [${key}]`);
 			return 0;
 		}
 
@@ -3800,7 +3800,7 @@ Redis.prototype.zrem = async function (key, members) {
 			});
 			return result;
 		} catch (err) {
-			this.logger('error', `移除有序集合成员失败 [${finalKey}]:`, err);
+			this.log('error', `移除有序集合成员失败 [${finalKey}]:`, err);
 			this.emit('zrem:error', {
 				key: finalKey,
 				members: finalMembers,
@@ -3811,7 +3811,7 @@ Redis.prototype.zrem = async function (key, members) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error', `移除有序集合成员失败 [${key}]:`, err);
+		this.log('error', `移除有序集合成员失败 [${key}]:`, err);
 		this.emit('zrem:error', {
 			key,
 			members,
@@ -3838,7 +3838,7 @@ Redis.prototype.zscore = async function (key, member) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error', `获取有序集合成员分数失败 [${key}:${member}]:`, err);
+		this.log('error', `获取有序集合成员分数失败 [${key}:${member}]:`, err);
 		return null;
 	}
 };
@@ -3860,7 +3860,7 @@ Redis.prototype.zrank = async function (key, member) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error', `获取有序集合成员排名失败 [${key}:${member}]:`, err);
+		this.log('error', `获取有序集合成员排名失败 [${key}:${member}]:`, err);
 		return null;
 	}
 };
@@ -3901,13 +3901,13 @@ Redis.prototype.zrange = async function (key, start, stop, withScores = false) {
 								member,
 								score: 0
 							});
-							this.logger('error', `获取成员 ${member} 分数失败:`, scoreErr);
+							this.log('error', `获取成员 ${member} 分数失败:`, scoreErr);
 						}
 					}
 
 					return results;
 				} catch (err) {
-					this.logger('error', `使用备用方法获取有序集合范围失败 [${prefixedKey}]:`, err);
+					this.log('error', `使用备用方法获取有序集合范围失败 [${prefixedKey}]:`, err);
 					// 回退到简单列表
 					return [];
 				}
@@ -3920,7 +3920,7 @@ Redis.prototype.zrange = async function (key, start, stop, withScores = false) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error', `获取有序集合范围成员失败 [${key}]:`, err);
+		this.log('error', `获取有序集合范围成员失败 [${key}]:`, err);
 		return [];
 	}
 };
@@ -3938,13 +3938,13 @@ Redis.prototype.zcard = async function (key) {
 			const result = await connection.zCard(this._addPrefix(key));
 			return result || 0;
 		} catch (err) {
-			this.logger('error', `获取有序集合成员数量失败 [${key}]:`, err);
+			this.log('error', `获取有序集合成员数量失败 [${key}]:`, err);
 			return 0;
 		} finally {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error', `获取有序集合成员数量失败 [${key}]:`, err);
+		this.log('error', `获取有序集合成员数量失败 [${key}]:`, err);
 		return 0;
 	}
 };
@@ -3981,7 +3981,7 @@ Redis.prototype.zincrby = async function (key, increment, member, seconds = 0) {
 		this.emit('zincrby:before', ctx);
 
 		if (ctx.cancel) {
-			this.logger('debug', `zincrby操作被事件处理器取消 [${key}]`);
+			this.log('debug', `zincrby操作被事件处理器取消 [${key}]`);
 			return null;
 		}
 
@@ -4017,7 +4017,7 @@ Redis.prototype.zincrby = async function (key, increment, member, seconds = 0) {
 			});
 			return parseFloat(result);
 		} catch (err) {
-			this.logger('error', `增加有序集合成员分数失败 [${finalKey}]:`, err);
+			this.log('error', `增加有序集合成员分数失败 [${finalKey}]:`, err);
 			this.emit('zincrby:error', {
 				key: finalKey,
 				increment: finalIncrement,
@@ -4030,7 +4030,7 @@ Redis.prototype.zincrby = async function (key, increment, member, seconds = 0) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error', `增加有序集合成员分数失败 [${key}]:`, err);
+		this.log('error', `增加有序集合成员分数失败 [${key}]:`, err);
 		this.emit('zincrby:error', {
 			key,
 			increment,
@@ -4064,19 +4064,19 @@ Redis.prototype._createConnection = function () {
 
 			// 监听错误事件
 			connection.on('error', (err) => {
-				this.logger('error', `连接 ${connection.id} 错误:`, err);
+				this.log('error', `连接 ${connection.id} 错误:`, err);
 			});
 
 			// 连接Redis
 			connection.connect().then(() => {
-				// this.logger('debug','新连接已创建并连接:', connection.id);
+				// this.log('debug','新连接已创建并连接:', connection.id);
 				resolve(connection);
 			}).catch(err => {
-				this.logger('error', '创建连接失败:', err);
+				this.log('error', '创建连接失败:', err);
 				reject(err);
 			});
 		} catch (error) {
-			this.logger('error', '创建连接时发生异常:', error);
+			this.log('error', '创建连接时发生异常:', error);
 			reject(error);
 		}
 	});