monsqlize 1.3.1 → 2.0.0

package/lib/slow-query-log/mongodb-storage.js

@@ -1,323 +0,0 @@
-/**
- * MongoDB慢查询日志存储实现
- * 实现方案B（更新记录去重）
- *
- * @version 1.3.0
- * @since 2025-12-22
- */
-
-const { ISlowQueryLogStorage } = require('./base-storage');
-const { generateQueryHash } = require('./query-hash');
-
-class MongoDBSlowQueryLogStorage extends ISlowQueryLogStorage {
-  /**
-   * 创建MongoDB存储实例
-   * @param {Object} config - 存储配置
-   * @param {string} [config.uri] - MongoDB连接URI（独立连接时）
-   * @param {string} [config.database='admin'] - 存储数据库
-   * @param {string} [config.collection='slow_query_logs'] - 存储集合
-   * @param {number} [config.ttl=604800] - TTL过期时间（秒）
-   * @param {string} [config.ttlField='lastSeen'] - TTL字段
-   * @param {Object} [client] - MongoDB客户端（复用连接时）
-   * @param {Object} [logger] - 日志记录器
-   */
-  constructor(config, client, logger) {
-    super();
-    this.config = config;
-    this.client = client;  // 可能是复用的业务连接
-    this.ownClient = null;  // 独立连接（如果创建）
-    this.collection = null;
-    this.logger = logger || console;
-    this.initialized = false;
-  }
-
-  /**
-   * 初始化存储（连接+创建索引）
-   * @returns {Promise<void>}
-   */
-  async initialize() {
-    if (this.initialized) {
-      return;
-    }
-
-    try {
-      // 如果没有传入client，创建独立连接
-      if (!this.client) {
-        if (!this.config.uri) {
-          throw new Error('MongoDB URI is required when client is not provided');
-        }
-
-        const { MongoClient } = require('mongodb');
-        this.ownClient = await MongoClient.connect(this.config.uri);
-        this.client = this.ownClient;
-
-        if (this.logger.info) {
-          this.logger.info(`[SlowQueryLog] Connected to MongoDB: ${this.config.uri}`);
-        }
-      }
-
-      // 获取数据库和集合
-      const dbName = this.config.database || 'admin';
-      const collName = this.config.collection || 'slow_query_logs';
-
-      this.db = this.client.db(dbName);
-      this.collection = this.db.collection(collName);
-
-      // 创建索引
-      await this.setupIndexes();
-
-      this.initialized = true;
-
-      if (this.logger.info) {
-        this.logger.info(
-          `[SlowQueryLog] Initialized MongoDB storage: ${dbName}.${collName}`
-        );
-      }
-    } catch (err) {
-      if (this.logger.error) {
-        this.logger.error('[SlowQueryLog] Failed to initialize MongoDB storage:', err);
-      }
-      throw err;
-    }
-  }
-
-  /**
-   * 创建索引
-   * @returns {Promise<void>}
-   */
-  async setupIndexes() {
-    try {
-      // 索引1：queryHash唯一索引（去重关键）
-      await this.collection.createIndex(
-        { queryHash: 1 },
-        { unique: true, name: 'idx_queryHash_unique' }
-      );
-
-      // 索引2：lastSeen TTL索引（自动过期）
-      const ttl = this.config.ttl || 7 * 24 * 3600;
-      const ttlField = this.config.ttlField || 'lastSeen';
-
-      await this.collection.createIndex(
-        { [ttlField]: 1 },
-        {
-          name: 'idx_lastSeen_ttl',
-          expireAfterSeconds: ttl
-        }
-      );
-
-      // 索引3：按集合查询（辅助索引）
-      await this.collection.createIndex(
-        { db: 1, collection: 1 },
-        { name: 'idx_db_collection' }
-      );
-
-      // 索引4：按执行次数查询（找高频慢查询）
-      await this.collection.createIndex(
-        { count: -1 },
-        { name: 'idx_count_desc' }
-      );
-
-      if (this.logger.debug) {
-        this.logger.debug('[SlowQueryLog] MongoDB indexes created successfully');
-      }
-    } catch (err) {
-      // 索引创建失败不应该阻塞功能
-      if (this.logger.warn) {
-        this.logger.warn('[SlowQueryLog] Failed to create some indexes:', err.message);
-      }
-    }
-  }
-
-  /**
-   * 保存单条慢查询日志（upsert）
-   * @param {Object} log - 慢查询日志对象
-   * @returns {Promise<void>}
-   */
-  async save(log) {
-    if (!this.initialized) {
-      await this.initialize();
-    }
-
-    const queryHash = generateQueryHash(log);
-    await this.upsert(queryHash, log);
-  }
-
-  /**
-   * 批量保存慢查询日志（bulkWrite + upsert）
-   * @param {Object[]} logs - 慢查询日志数组
-   * @returns {Promise<void>}
-   */
-  async saveBatch(logs) {
-    if (!this.initialized) {
-      await this.initialize();
-    }
-
-    if (!logs || logs.length === 0) {
-      return;
-    }
-
-    try {
-      // 构建bulkWrite操作数组
-      const operations = logs.map(log => {
-        const queryHash = generateQueryHash(log);
-        const timestamp = log.timestamp || new Date();
-        const executionTimeMs = log.executionTimeMs || log.ms || 0;
-
-        return {
-          updateOne: {
-            filter: { queryHash },
-            update: {
-              $set: {
-                lastSeen: timestamp,
-                lastExecution: {
-                  executionTimeMs,
-                  timestamp,
-                  metadata: log.metadata || {}
-                }
-              },
-              $inc: {
-                count: 1,
-                totalTimeMs: executionTimeMs
-              },
-              $min: { minTimeMs: executionTimeMs },
-              $max: { maxTimeMs: executionTimeMs },
-              $setOnInsert: {
-                queryHash,
-                db: log.db,
-                collection: log.collection || log.coll,
-                operation: log.operation || log.op,
-                queryShape: log.queryShape || {},
-                type: log.type || 'mongodb',
-                firstSeen: timestamp
-              }
-            },
-            upsert: true
-          }
-        };
-      });
-
-      // 批量写入（ordered=false 允许部分失败）
-      const result = await this.collection.bulkWrite(operations, { ordered: false });
-
-      if (this.logger.debug) {
-        this.logger.debug(
-          `[SlowQueryLog] Batch saved: ${result.upsertedCount} inserted, ` +
-          `${result.modifiedCount} updated`
-        );
-      }
-    } catch (err) {
-      if (this.logger.error) {
-        this.logger.error('[SlowQueryLog] Failed to save batch:', err);
-      }
-      throw err;
-    }
-  }
-
-  /**
-   * 单条upsert操作
-   * @param {string} queryHash - 查询Hash
-   * @param {Object} log - 慢查询日志对象
-   * @returns {Promise<void>}
-   */
-  async upsert(queryHash, log) {
-    const timestamp = log.timestamp || new Date();
-    const executionTimeMs = log.executionTimeMs || log.ms || 0;
-
-    await this.collection.updateOne(
-      { queryHash },
-      {
-        $set: {
-          lastSeen: timestamp,
-          lastExecution: {
-            executionTimeMs,
-            timestamp,
-            metadata: log.metadata || {}
-          }
-        },
-        $inc: {
-          count: 1,
-          totalTimeMs: executionTimeMs
-        },
-        $min: { minTimeMs: executionTimeMs },
-        $max: { maxTimeMs: executionTimeMs },
-        $setOnInsert: {
-          queryHash,
-          db: log.db,
-          collection: log.collection || log.coll,
-          operation: log.operation || log.op,
-          queryShape: log.queryShape || {},
-          type: log.type || 'mongodb',
-          firstSeen: timestamp
-        }
-      },
-      { upsert: true }
-    );
-  }
-
-  /**
-   * 查询慢查询日志
-   * @param {Object} filter - 查询条件
-   * @param {Object} options - 查询选项
-   * @returns {Promise<Object[]>}
-   */
-  async query(filter = {}, options = {}) {
-    if (!this.initialized) {
-      await this.initialize();
-    }
-
-    try {
-      const cursor = this.collection.find(filter);
-
-      if (options.sort) {
-        cursor.sort(options.sort);
-      }
-      if (options.limit) {
-        cursor.limit(options.limit);
-      }
-      if (options.skip) {
-        cursor.skip(options.skip);
-      }
-
-      const results = await cursor.toArray();
-
-      // 计算avgTimeMs（动态计算）
-      return results.map(doc => ({
-        ...doc,
-        avgTimeMs: doc.count > 0 ? Math.round(doc.totalTimeMs / doc.count) : 0
-      }));
-    } catch (err) {
-      if (this.logger.error) {
-        this.logger.error('[SlowQueryLog] Failed to query:', err);
-      }
-      return [];
-    }
-  }
-
-  /**
-   * 关闭连接
-   * @returns {Promise<void>}
-   */
-  async close() {
-    // 只关闭自己创建的连接，不关闭复用的连接
-    if (this.ownClient) {
-      try {
-        await this.ownClient.close();
-        if (this.logger.info) {
-          this.logger.info('[SlowQueryLog] MongoDB connection closed');
-        }
-      } catch (err) {
-        if (this.logger.error) {
-          this.logger.error('[SlowQueryLog] Failed to close MongoDB connection:', err);
-        }
-      }
-      this.ownClient = null;
-    }
-
-    this.client = null;
-    this.collection = null;
-    this.initialized = false;
-  }
-}
-
-module.exports = { MongoDBSlowQueryLogStorage };
-

package/lib/slow-query-log/query-hash.js

@@ -1,38 +0,0 @@
-/**
- * 慢查询Hash生成工具
- * 用于生成queryHash（去重标识）
- *
- * @version 1.3.0
- * @since 2025-12-22
- */
-
-const crypto = require('crypto');
-
-/**
- * 生成慢查询的唯一Hash标识
- * @param {Object} log - 慢查询日志对象
- * @param {string} log.db - 数据库名
- * @param {string} log.collection - 集合名
- * @param {string} log.operation - 操作类型
- * @param {Object} log.queryShape - 查询模式（已脱敏）
- * @returns {string} 16位Hash字符串
- */
-function generateQueryHash(log) {
-  // 构建唯一键（不包含executionTimeMs、timestamp等动态字段）
-  const key = JSON.stringify({
-    db: log.db || '',
-    collection: log.collection || log.coll || '',
-    operation: log.operation || log.op || '',
-    queryShape: log.queryShape || {}
-  });
-
-  // 生成SHA256 Hash，取前16位
-  return crypto
-    .createHash('sha256')
-    .update(key)
-    .digest('hex')
-    .substring(0, 16);
-}
-
-module.exports = { generateQueryHash };
-

package/lib/transaction/CacheLockManager.js

@@ -1,161 +0,0 @@
-/**
- * 缓存锁管理器
- * 用于在事务执行期间锁定缓存键，防止脏数据写入缓存
- */
-
-class CacheLockManager {
-    constructor(options = {}) {
-        this.locks = new Map(); // key -> { sessionId, expiresAt }
-        this.maxDuration = options.maxDuration || 300000; // 5分钟默认
-        this.lockCleanupInterval = options.lockCleanupInterval || 10000; // 10秒清理一次
-        this.cleanupTimer = null;
-
-        // 启动自动清理
-        this._startCleanup();
-    }
-
-    /**
-     * 添加缓存锁
-     * @param {string} key - 缓存键（支持通配符 *）
-     * @param {Object} session - MongoDB session 对象
-     */
-    addLock(key, session) {
-        if (!session || !session.id) {
-            return;
-        }
-
-        const sessionId = session.id.toString();
-        const expiresAt = Date.now() + this.maxDuration;
-
-        this.locks.set(key, {
-            sessionId,
-            expiresAt,
-            lockedAt: Date.now()
-        });
-    }
-
-    /**
-     * 检查缓存键是否被锁定
-     * @param {string} key - 缓存键
-     * @returns {boolean}
-     */
-    isLocked(key) {
-        // 精确匹配
-        if (this.locks.has(key)) {
-            const lock = this.locks.get(key);
-            if (Date.now() < lock.expiresAt) {
-                return true;
-            }
-            // 过期自动删除
-            this.locks.delete(key);
-        }
-
-        // 通配符匹配
-        for (const [lockKey, lock] of this.locks.entries()) {
-            if (lockKey.includes('*')) {
-                const pattern = lockKey.replace(/\*/g, '.*');
-                const regex = new RegExp(`^${pattern}$`);
-                if (regex.test(key)) {
-                    if (Date.now() < lock.expiresAt) {
-                        return true;
-                    }
-                    // 过期自动删除
-                    this.locks.delete(lockKey);
-                }
-            }
-        }
-
-        return false;
-    }
-
-    /**
-     * 释放指定 session 的所有锁
-     * @param {Object} session - MongoDB session 对象
-     */
-    releaseLocks(session) {
-        if (!session || !session.id) {
-            return;
-        }
-
-        const sessionId = session.id.toString();
-        const keysToDelete = [];
-
-        for (const [key, lock] of this.locks.entries()) {
-            if (lock.sessionId === sessionId) {
-                keysToDelete.push(key);
-            }
-        }
-
-        keysToDelete.forEach(key => this.locks.delete(key));
-    }
-
-    /**
-     * 清理过期的锁
-     * @private
-     */
-    _cleanupExpiredLocks() {
-        const now = Date.now();
-        const keysToDelete = [];
-
-        for (const [key, lock] of this.locks.entries()) {
-            if (now >= lock.expiresAt) {
-                keysToDelete.push(key);
-            }
-        }
-
-        if (keysToDelete.length > 0) {
-            keysToDelete.forEach(key => this.locks.delete(key));
-        }
-    }
-
-    /**
-     * 启动自动清理定时器
-     * @private
-     */
-    _startCleanup() {
-        if (this.cleanupTimer) {
-            return;
-        }
-
-        this.cleanupTimer = setInterval(() => {
-            this._cleanupExpiredLocks();
-        }, this.lockCleanupInterval);
-
-        // 防止定时器阻止进程退出
-        if (this.cleanupTimer.unref) {
-            this.cleanupTimer.unref();
-        }
-    }
-
-    /**
-     * 停止自动清理
-     */
-    stop() {
-        if (this.cleanupTimer) {
-            clearInterval(this.cleanupTimer);
-            this.cleanupTimer = null;
-        }
-    }
-
-    /**
-     * 获取当前锁的统计信息
-     */
-    getStats() {
-        return {
-            totalLocks: this.locks.size,
-            activeLocks: Array.from(this.locks.values()).filter(
-                lock => Date.now() < lock.expiresAt
-            ).length
-        };
-    }
-
-    /**
-     * 清除所有锁（用于测试）
-     */
-    clear() {
-        this.locks.clear();
-    }
-}
-
-module.exports = CacheLockManager;
-