rl-rockcli 0.0.2 → 0.0.4

package/commands/log/core/utils.js

@@ -1,424 +0,0 @@
-const path = require('path');
-const fs = require('fs');
-
-// 加载集群表映射配置
-const clusterMappingPath = path.join(__dirname, '../../../config/cluster_table_mapping.json');
-let clusterTableMapping = { clusters: {} };
-if (fs.existsSync(clusterMappingPath)) {
-    clusterTableMapping = JSON.parse(fs.readFileSync(clusterMappingPath, 'utf8'));
-}
-
-/**
- * 检查字段是否应该在格式化模式下被过滤
- * @param {string} fieldName - 字段名
- * @returns {boolean} 是否应该被过滤
- */
-function isBlacklisted(fieldName) {
-    const { BLACKLIST_FIELDS } = require('./constants');
-    // 黑名单所有以 @ 开头的字段（仅在格式化模式下）
-    if (fieldName.startsWith('@')) return true;
-    // 黑名单 BLACKLIST_FIELDS 中的字段
-    if (BLACKLIST_FIELDS.includes(fieldName)) return true;
-    return false;
-}
-
-/**
- * 解析时间字符串为时间戳
- * @param {string} timeStr - 时间字符串
- * @returns {number|null} 时间戳（毫秒）
- */
-function parseTime(timeStr) {
-    if (!timeStr) return null;
-
-    // 如果是纯数字，智能判断是秒级还是毫秒级时间戳
-    if (/^\d+$/.test(timeStr)) {
-        const timestamp = parseInt(timeStr);
-        // Unix 时间戳标准是秒级的（10位数字），毫秒级通常是13位数字
-        // 如果数字长度 <= 10，认为是秒级时间戳，需要转换为毫秒
-        // 如果数字长度 > 10，认为是毫秒级时间戳，直接使用
-        if (timestamp <= 9999999999) {
-            return timestamp * 1000; // 秒级 -> 毫秒级
-        } else {
-            return timestamp; // 已经是毫秒级
-        }
-    }
-
-    // 解析相对时间格式（如 "15m", "1h", "2d"）
-    const relativeMatch = timeStr.match(/^(\d+)([mhd])$/);
-    if (relativeMatch) {
-        const value = parseInt(relativeMatch[1]);
-        const unit = relativeMatch[2];
-        const now = Date.now();
-        switch (unit) {
-            case 'm': return now - value * 60 * 1000; // 分钟
-            case 'h': return now - value * 60 * 60 * 1000; // 小时
-            case 'd': return now - value * 24 * 60 * 60 * 1000; // 天
-        }
-    }
-
-    // 尝试解析为日期字符串
-    const date = new Date(timeStr);
-    if (!isNaN(date.getTime())) {
-        return date.getTime();
-    }
-
-    throw new Error(`无法解析时间格式: ${timeStr}`);
-}
-
-/**
- * 生成日志的唯一键，用于去重
- * @param {Object} log - 日志对象
- * @returns {string} 唯一键
- */
-function getLogUniqueKey(log) {
-    const source = log['@source'] || '';
-    const filename = log['@filename'] || '';
-    const packId = log['@packId'] || 0;
-    const logGroupOrder = log['@logGroupOrder'] || 0;
-    return `${source}:${filename}:${packId}:${logGroupOrder}`;
-}
-
-/**
- * 从字段过滤器中提取 @source 和 @filename 的值
- * @param {Array} fieldFilters - 字段过滤器数组
- * @returns {Object} 包含 source 和 filename 的对象
- */
-function extractSourceAndFilename(fieldFilters) {
-    let source = null;
-    let filename = null;
-
-    if (fieldFilters && Array.isArray(fieldFilters)) {
-        fieldFilters.forEach(f => {
-            const sourceMatch = f.match(/^@source=(.+)$/);
-            const filenameMatch = f.match(/^@filename=(.+)$/);
-
-            if (sourceMatch) {
-                source = sourceMatch[1];
-            }
-            if (filenameMatch) {
-                filename = filenameMatch[1];
-            }
-        });
-    }
-
-    return { source, filename };
-}
-
-/**
- * 检查两条日志是否连续（同IP、同文件，且序号相邻）
- * @param {Object} log1 - 前一条日志
- * @param {Object} log2 - 后一条日志
- * @returns {boolean} 是否连续
- */
-function areLogsConsecutive(log1, log2) {
-    if (!log1 || !log2) return false;
-
-    const source1 = log1['@source'] || '';
-    const source2 = log2['@source'] || '';
-    const filename1 = log1['@filename'] || '';
-    const filename2 = log2['@filename'] || '';
-
-    // 必须是同一IP和文件
-    if (source1 !== source2 || filename1 !== filename2) return false;
-
-    const packId1 = parseInt(log1['@packId']) || 0;
-    const packId2 = parseInt(log2['@packId']) || 0;
-    const order1 = parseInt(log1['@logGroupOrder']) || 0;
-    const order2 = parseInt(log2['@logGroupOrder']) || 0;
-
-    // 同一个packId，order差1
-    if (packId1 === packId2 && order2 - order1 === 1) {
-        return true;
-    }
-
-    // packId差1，且log1是某packId的最后一条，log2是下一个packId的第一条
-    // 简化判断：packId差1且order2=0
-    if (packId2 - packId1 === 1 && order2 === 0) {
-        return true;
-    }
-
-    return false;
-}
-
-/**
- * 构建查询字符串
- * @param {Object} options - 查询选项
- * @param {string} options.keyword - 关键词
- * @param {Array} options.field - 字段过滤条件
- * @param {string} options.query - 直接查询字符串
- * @param {string} options.sandboxId - 沙箱ID
- * @param {string} options.logFile - 日志文件名
- * @param {string} options.role - 用户角色（用于权限控制）
- * @returns {string} 查询字符串
- */
-function buildQueryString({ keyword, field, query, sandboxId, logFile, role }) {
-    // 条件引用：内网专有模块（开源版不存在）
-    let Roles, ALLOWED_LOG_FILES;
-    try {
-        const access_control = require('../../../lib/access_control');
-        Roles = access_control.Roles;
-        ALLOWED_LOG_FILES = access_control.ALLOWED_LOG_FILES;
-    } catch (e) {
-        // 开源版：无权限控制，使用空实现
-        Roles = {};
-        ALLOWED_LOG_FILES = [];
-    }
-
-    let queryString = '';
-
-    // 如果提供了 --query，直接使用
-    if (query) {
-        queryString = query;
-    } else {
-        // 否则从 keyword 和 field 构建
-        const queryParts = [];
-
-        // 添加关键词搜索
-        if (keyword) {
-            const keywords = Array.isArray(keyword) ? keyword : [keyword];
-            keywords.forEach(kw => {
-                if (kw && typeof kw === 'string') {
-                    // 直接使用关键词，不使用引号包裹
-                    queryParts.push(kw);
-                }
-            });
-        }
-
-        // 添加字段搜索
-        if (field && field.length > 0) {
-            field.forEach(f => {
-                const negationMatch = f.match(/^([^!=]+)!=(.*)$/);
-                // 比较运算符匹配：>=, <=, >, < （必须在等值运算符之前检查，避免错误的匹配）
-                // 使用 \w+ 来匹配字段名，避免匹配到运算符字符
-                const greaterEqualMatch = f.match(/^(\w+)>=(.*)$/);
-                const lessEqualMatch = f.match(/^(\w+)<=(.*)$/);
-                const greaterMatch = f.match(/^(\w+)>(.*)$/);
-                const lessMatch = f.match(/^(\w+)<(.*)$/);
-                const equalMatch = f.match(/^([^=]+)=(.*)$/);
-
-                if (negationMatch) {
-                    const [, fieldName, fieldValue] = negationMatch;
-                    // 暂时注释掉 _exists_ 逻辑
-                    // queryParts.push(`_exists_:${fieldName} and not ${fieldName}:${fieldValue}`);
-                    queryParts.push(`not ${fieldName}:${fieldValue}`);
-                } else if (greaterEqualMatch) {
-                    // status>=500 → status:[500 TO *}
-                    const [, fieldName, fieldValue] = greaterEqualMatch;
-                    queryParts.push(`${fieldName}:[${fieldValue} TO *}`);
-                } else if (lessEqualMatch) {
-                    // status<=500 → status:{* TO 500]
-                    const [, fieldName, fieldValue] = lessEqualMatch;
-                    queryParts.push(`${fieldName}:{* TO ${fieldValue}]`);
-                } else if (greaterMatch) {
-                    // status>500 → status:{500 TO *}
-                    const [, fieldName, fieldValue] = greaterMatch;
-                    queryParts.push(`${fieldName}:{${fieldValue} TO *}`);
-                } else if (lessMatch) {
-                    // status<500 → status:{* TO 500}
-                    const [, fieldName, fieldValue] = lessMatch;
-                    queryParts.push(`${fieldName}:{* TO ${fieldValue}}`);
-                } else if (equalMatch) {
-                    const [, fieldName, fieldValue] = equalMatch;
-                    // 暂时注释掉 _exists_ 逻辑
-                    // queryParts.push(`${fieldName}:${fieldValue} and _exists_:${fieldName}`);
-                    queryParts.push(`${fieldName}:${fieldValue}`);
-                }
-            });
-        }
-
-        queryString = queryParts.join(' and ');
-    }
-
-    // 添加沙箱ID过滤
-    if (sandboxId) {
-        let sandboxFilter;
-        if (logFile) {
-            // 指定了 logFile，精确匹配
-            sandboxFilter = `@filename:/data/logs/${sandboxId}/${logFile}`;
-        } else if (role === Roles.SUPER_ADMIN) {
-            // 管理员：保持现有逻辑，可匹配多种来源（包含 swe-rex.log）
-            sandboxFilter = `(sandbox_id:${sandboxId} or ${sandboxId} or x22${sandboxId} or x0A${sandboxId} or @filename:/data/logs/${sandboxId}/command.log or @filename:/data/logs/${sandboxId}/swe-rex.log or @filename:/data/logs/${sandboxId}/rocklet.log)`;
-        } else {
-            // 普通用户：只能通过 @filename 白名单路径查询
-            const allowedPaths = ALLOWED_LOG_FILES
-                .map(file => `@filename:/data/logs/${sandboxId}/${file}`)
-                .join(' or ');
-            sandboxFilter = `(${allowedPaths})`;
-        }
-
-        if (queryString) {
-            queryString = `${sandboxFilter} and ${queryString}`;
-        } else {
-            queryString = sandboxFilter;
-        }
-    }
-
-    return queryString;
-}
-
-/**
- * @param {string|null} cluster - 指定的集群名称
- * @returns {Array} 查询列表 [{ clusterName, logType, tableName }]
- */
-function getQueriesToRun(cluster) {
-    // 条件引用：内网专有模块（开源版不存在）
-    let unifiedClient;
-    try {
-        const unified_log_client = require('../../../utils/unified_log_client');
-        unifiedClient = unified_log_client.client;
-    } catch (e) {
-        // 开源版：无统一日志客户端，使用空实现
-        unifiedClient = null;
-    }
-
-    const queriesToRun = [];
-    const queriedTables = new Set();
-    const clustersToQuery = cluster
-        ? [cluster]
-        : Object.keys(clusterTableMapping.clusters);
-
-    clustersToQuery.forEach(clusterName => {
-        const clusterConfig = clusterTableMapping.clusters[clusterName];
-        if (clusterConfig) {
-            Object.keys(clusterConfig).forEach(logType => {
-                const tableName = clusterConfig[logType];
-                if (tableName && !queriedTables.has(tableName)) {
-                    queriedTables.add(tableName);
-                    queriesToRun.push({ clusterName, logType, tableName });
-                }
-            });
-        } else if (clusterName === 'nt-c') {
-            const tableName = unifiedClient.defaultTableName;
-            if (!queriedTables.has(tableName)) {
-                queriedTables.add(tableName);
-                queriesToRun.push({ clusterName, logType: 'log', tableName });
-            }
-        }
-    });
-
-    return queriesToRun;
-}
-
-/**
- * 反转义日志字符串
- * 参考: python3 -c "import sys; print(sys.stdin.read().encode().decode('unicode_escape').encode('latin-1').decode('utf-8'))"
- * @param {string} str - 需要反转义的字符串
- * @returns {string|null} 反转义后的字符串
- */
-function unescapeLogString(str) {
-    if (!str || str === '-') return null;
-
-    // 处理 \xXX 格式的转义字符
-    const hexEscaped = str.replace(/\\x([0-9A-Fa-f]{2})/g, (match, hex) => {
-        return String.fromCharCode(parseInt(hex, 16));
-    });
-
-    // 处理 Unicode 转义序列 \uXXXX
-    const unicodeEscaped = hexEscaped.replace(/\\u([0-9A-Fa-f]{4})/g, (match, hex) => {
-        return String.fromCharCode(parseInt(hex, 16));
-    });
-
-    // 处理常见的转义字符
-    const commonEscaped = unicodeEscaped
-        .replace(/\\n/g, '\n')
-        .replace(/\\r/g, '\r')
-        .replace(/\\t/g, '\t')
-        .replace(/\\"/g, '"')
-        .replace(/\\\\/g, '\\')
-        .replace(/\\'/g, "'");
-
-    return commonEscaped;
-}
-
-/**
- * 从 nginx 日志中提取沙箱ID
- * 优先级：
- * 1. 从 URI 参数中提取 sandbox_id
- * 2. 从反转义后的 request_body 中提取（JSON 或表单格式）
- * @param {Object} log - nginx 日志对象
- * @returns {string|null} 沙箱ID，未找到返回 null
- */
-function extractSandboxIdFromNginxLog(log) {
-    // 1. 从 URI 参数中提取 sandbox_id
-    const uri = log.request_uri || '';
-    const uriMatch = uri.match(/[?&]sandbox_id=([^&]+)/);
-    if (uriMatch) {
-        return uriMatch[1];
-    }
-
-    // 2. 从 request_body 中提取
-    const requestBody = log.request_body || '';
-    if (!requestBody || requestBody === '-') {
-        return null;
-    }
-
-    try {
-        // 反转义 request_body
-        const unescapedBody = unescapeLogString(requestBody);
-        if (!unescapedBody) {
-            return null;
-        }
-
-        // 尝试解析为 JSON
-        try {
-            const jsonData = JSON.parse(unescapedBody);
-            if (jsonData.sandbox_id) {
-                return jsonData.sandbox_id;
-            }
-        } catch (e) {
-            // 不是 JSON，尝试解析为表单格式
-        }
-
-        // 尝试解析为表单格式 (application/x-www-form-urlencoded)
-        const formDataPairs = unescapedBody.split('&');
-        for (const pair of formDataPairs) {
-            const [key, value] = pair.split('=');
-            if (key === 'sandbox_id' && value) {
-                return decodeURIComponent(value);
-            }
-        }
-
-        // 尝试解析为 multipart/form-data 格式
-        const formDataMatch = unescapedBody.match(/name="sandbox_id"[\s\S]*?\r?\n\r?\n([\s\S]*?)(?:\r?\n--|$)/);
-        if (formDataMatch) {
-            return formDataMatch[1].trim();
-        }
-    } catch (error) {
-        // 解析失败，返回 null
-    }
-
-    return null;
-}
-
-/**
- * 移除 URI 的前缀（如 /apis/envs/sandbox/v1/）
- * @param {string} uri - 原始 URI
- * @param {string} prefix - 要移除的前缀，默认为 /apis/envs/sandbox/v1/
- * @returns {string} 移除前缀后的 URI
- */
-function removeUriPrefix(uri, prefix = '/apis/envs/sandbox/v1/') {
-    if (!uri || typeof uri !== 'string') {
-        return uri || '';
-    }
-
-    // 移除前缀
-    if (uri.startsWith(prefix)) {
-        return uri.substring(prefix.length);
-    }
-
-    return uri;
-}
-
-module.exports = {
-    clusterTableMapping,
-    isBlacklisted,
-    parseTime,
-    getLogUniqueKey,
-    extractSourceAndFilename,
-    areLogsConsecutive,
-    buildQueryString,
-    getQueriesToRun,
-    unescapeLogString,
-    extractSandboxIdFromNginxLog,
-    removeUriPrefix,
-};