koishi-plugin-share-links-analysis 0.8.1 → 0.8.2

package/lib/index.js

@@ -112,7 +112,42 @@ exports.Config = koishi_1.Schema.intersect([
         userAgent: koishi_1.Schema.string().description("所有 API 请求所用的 User-Agent").default("Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36"),
         debug: koishi_1.Schema.boolean().default(false).description("开启调试模式 (输出详细日志)"),
     }).description("调试设置"),
+    koishi_1.Schema.object({
+        reportEnabled: koishi_1.Schema.boolean().default(false).description("开启性能数据上报"),
+        reportUrl: koishi_1.Schema.string().default("http://127.0.0.1:8080/").description("性能数据上报地址 (HTTP POST)"),
+    }).description("性能监控"),
 ]);
+async function reportMetric(ctx, config, payload) {
+    if (!config.reportEnabled || !config.reportUrl)
+        return;
+    const data = {
+        app: "share_links_analysis", // 必填 app 标识
+        timestamp: Math.floor(Date.now() / 1000), // 可选时间戳
+        ...payload
+    };
+    // 异步发送，不阻塞主流程
+    ctx.http.post(config.reportUrl, data).catch(e => {
+        // 仅在调试模式下打印上报错误，避免刷屏
+        if (config.debug) {
+            ctx.logger('share-links-analysis').warn(`性能数据上报失败: ${e.message}`);
+        }
+    });
+}
+async function sendResult(ctx, session, config, result, logger) {
+    if (!session.channel) {
+        return await (0, utils_1.sendResult_plain)(ctx, session, config, result, logger);
+    }
+    switch (config.useForward) {
+        case "plain":
+            return await (0, utils_1.sendResult_plain)(ctx, session, config, result, logger);
+        case 'forward':
+            return await (0, utils_1.sendResult_forward)(ctx, session, config, result, logger, false);
+        case "mixed":
+            return await (0, utils_1.sendResult_forward)(ctx, session, config, result, logger, true);
+        default:
+            return { downloadTime: 0, sendTime: 0 };
+    }
+}
 function apply(ctx, config) {
     // 数据库模型定义
     ctx.model.extend('sla_cookie_cache', {
@@ -237,7 +272,7 @@ function apply(ctx, config) {
     });
     // 清除缓存指令
     cmd.subcommand('.clean', '清除所有缓存和文件', { authority: 3 })
-        .action(async ({ session }) => {
+        .action(async () => {
         await ctx.database.remove('sla_parse_cache', {});
         const allFiles = await ctx.database.get('sla_file_cache', {});
         for (const file of allFiles) {
@@ -246,7 +281,8 @@ function apply(ctx, config) {
                     await fs.promises.unlink(file.path);
                 }
             }
-            catch { }
+            catch {
+            }
         }
         await ctx.database.remove('sla_file_cache', {});
         return '缓存及对应文件已清理。';
@@ -297,87 +333,145 @@ function apply(ctx, config) {
             if (config.waitTip_Switch) {
                 await session.send(config.waitTip_Switch);
             }
+            // === 性能统计变量 ===
+            const startTotal = Date.now();
+            let parseTime = 0;
+            let downloadTime = 0;
+            let sendTime = 0;
+            let isCache = false;
+            let status = "success";
+            let errorMsg = "";
+            let errorStack = "";
             // === 缓存与并发控制逻辑 ===
             let result = null;
             const cacheKey = `${link.platform}:${link.id}`;
-            // 1. 查持久化缓存 (DB)
-            if (config.enableCache) {
-                const cached = await ctx.database.get('sla_parse_cache', cacheKey);
-                // 检查是否存在且未过期
-                if (cached.length > 0) {
-                    const entry = cached[0];
-                    const isExpired = config.cacheExpiration > 0 && (Date.now() - entry.created_at > config.cacheExpiration * 60 * 60 * 1000);
-                    if (!isExpired) {
-                        logger.debug(`使用缓存解析结果: ${cacheKey}`);
-                        result = entry.data;
-                    }
-                    else {
-                        // 过期删除
-                        await ctx.database.remove('sla_parse_cache', { key: cacheKey });
+            try {
+                // 1. 查持久化缓存 (DB)
+                if (config.enableCache) {
+                    const cached = await ctx.database.get('sla_parse_cache', cacheKey);
+                    // 检查是否存在且未过期
+                    if (cached.length > 0) {
+                        const entry = cached[0];
+                        const isExpired = config.cacheExpiration > 0 && (Date.now() - entry.created_at > config.cacheExpiration * 60 * 60 * 1000);
+                        if (!isExpired) {
+                            logger.debug(`使用缓存解析结果: ${cacheKey}`);
+                            result = entry.data;
+                            isCache = true;
+                        }
+                        else {
+                            // 过期删除
+                            await ctx.database.remove('sla_parse_cache', { key: cacheKey });
+                        }
                     }
                 }
-            }
-            // 2. 查内存任务队列
-            if (!result) {
-                if (pendingChecks.has(cacheKey)) {
-                    logger.debug(`检测到正在进行的解析任务，正在等待合并结果: ${cacheKey}`);
-                    // 如果有相同的任务正在进行，直接等待它的结果
-                    result = await pendingChecks.get(cacheKey) || null;
-                }
-                else {
-                    // 如果没有，创建一个新的 Promise 任务
-                    const task = (async () => {
+                // 2. 查内存任务队列
+                if (!result) {
+                    if (pendingChecks.has(cacheKey)) {
+                        logger.debug(`检测到正在进行的解析任务，正在等待合并结果: ${cacheKey}`);
+                        // 如果有相同的任务正在进行，直接等待它的结果
                         try {
-                            const res = await (0, core_1.processLink)(ctx, config, link, session);
-                            // 解析成功且开启缓存，则写入 DB
-                            if (res && config.enableCache) {
-                                await ctx.database.upsert('sla_parse_cache', [{
-                                        key: cacheKey,
-                                        data: res,
-                                        created_at: Date.now()
-                                    }]);
-                            }
-                            return res;
+                            result = await pendingChecks.get(cacheKey) || null;
                         }
                         catch (e) {
-                            logger.warn(`解析任务出错: ${e}`);
-                            return null;
+                            // 如果等待的任务失败了，这里也会捕获到
+                            throw e;
                         }
-                    })();
-                    // 将任务存入 Map
-                    pendingChecks.set(cacheKey, task);
-                    try {
-                        result = await task;
                     }
-                    finally {
-                        // 无论成功失败，任务结束后从 Map 中移除
-                        pendingChecks.delete(cacheKey);
+                    else {
+                        // 如果没有，创建一个新的 Promise 任务
+                        const task = (async () => {
+                            const t = Date.now();
+                            try {
+                                const res = await (0, core_1.processLink)(ctx, config, link, session);
+                                // 解析成功且开启缓存，则写入 DB
+                                if (res && config.enableCache) {
+                                    await ctx.database.upsert('sla_parse_cache', [{
+                                            key: cacheKey,
+                                            data: res,
+                                            created_at: Date.now()
+                                        }]);
+                                }
+                                return res;
+                            }
+                            catch (e) {
+                                logger.warn(`解析任务出错: ${e}`);
+                                throw e;
+                            }
+                            finally {
+                                // 执行上报
+                                // 无论成功失败，都在 finally 中上报数据
+                                parseTime = Date.now() - t;
+                            }
+                        })();
+                        // 将任务存入 Map
+                        pendingChecks.set(cacheKey, task);
+                        try {
+                            result = await task;
+                        }
+                        finally {
+                            // 无论成功失败，任务结束后从 Map 中移除
+                            pendingChecks.delete(cacheKey);
+                        }
                     }
                 }
+                // === 逻辑结束 ===
+                if (result) {
+                    lastProcessedUrls[channelId][link.url] = Date.now();
+                    const stats = await sendResult(ctx, session, config, result, logger);
+                    downloadTime = stats.downloadTime;
+                    sendTime = stats.sendTime;
+                }
+                else {
+                    status = "failed";
+                    errorMsg = "parser_returned_null";
+                    // 即使没有抛错，如果返回 null，也可以视为一种“软失败”，记录一下
+                }
+                linkCount++;
             }
-            // === 逻辑结束 ===
-            if (result) {
-                lastProcessedUrls[channelId][link.url] = Date.now();
-                await sendResult(ctx, session, config, result, logger);
+            catch (e) {
+                status = "error";
+                errorMsg = e.message || String(e);
+                errorStack = e.stack || String(e);
+                logger.warn(`处理异常: ${e}`);
+            }
+            finally {
+                // 4. 上报数据
+                const totalTime = Date.now() - startTotal;
+                // 获取内存使用情况 (MB)
+                const memoryUsage = process.memoryUsage();
+                const rssMB = (memoryUsage.rss / 1024 / 1024).toFixed(2);
+                // 截取堆栈前 1000 个字符，防止数据包过大（根据您的后端数据库限制调整）
+                const truncatedStack = errorStack.length > 1000 ? errorStack.substring(0, 1000) + "..." : errorStack;
+                reportMetric(ctx, config, {
+                    type: "link_process", // 业务类型
+                    // Tags
+                    platform: link.platform,
+                    status: status,
+                    is_cache: isCache.toString(),
+                    using_local: config.usingLocal.toString(),
+                    user_id: session.userId || "unknown",
+                    // [新增] 上下文信息，帮助定位是哪个群/频道
+                    guild_id: session.guildId || "private",
+                    channel_id: session.channelId || "unknown",
+                    // [新增] 核心复现数据：具体的 URL
+                    // 注意：如果您的后端是时序数据库(InfluxDB等)，URL作为Tag可能会导致基数爆炸(High Cardinality)。
+                    // 但根据您的描述是存入 tags 列用于筛选，且为内网服务，通常问题不大。
+                    target_url: link.url,
+                    // [新增] 错误信息
+                    error_msg: errorMsg,
+                    // 建议将堆栈放入 tags (如果数据库支持长文本) 或者单独的 log 字段
+                    // 这里放入 tags 供查阅
+                    error_stack: status === 'error' ? truncatedStack : "",
+                    // === Metrics (数值/指标) ===
+                    time_total_ms: totalTime,
+                    time_parse_ms: parseTime,
+                    time_download_ms: downloadTime,
+                    time_send_ms: sendTime,
+                    // 系统负载指标
+                    memory_rss_mb: parseFloat(rssMB), // 当前进程内存占用
+                    concurrent_tasks: pendingChecks.size, // 当前正在进行的并发解析数
+                });
             }
-            linkCount++;
         }
     });
 }
-async function sendResult(ctx, session, config, result, logger) {
-    if (!session.channel) {
-        await (0, utils_1.sendResult_plain)(ctx, session, config, result, logger);
-        return;
-    }
-    switch (config.useForward) {
-        case "plain":
-            await (0, utils_1.sendResult_plain)(ctx, session, config, result, logger);
-            return;
-        case 'forward':
-            await (0, utils_1.sendResult_forward)(ctx, session, config, result, logger, false);
-            return;
-        case "mixed":
-            await (0, utils_1.sendResult_forward)(ctx, session, config, result, logger, true);
-            return;
-    }
-}

package/lib/types.d.ts

@@ -43,6 +43,12 @@ export interface PluginConfig {
     localDownloadDir: string;
     userAgent: string;
     debug: boolean;
+    reportEnabled: boolean;
+    reportUrl: string;
+}
+export interface SendResultStats {
+    downloadTime: number;
+    sendTime: number;
 }
 export interface BilibiliVideoInfo {
     data: {

package/lib/utils.d.ts

@@ -1,4 +1,4 @@
-import { ParsedInfo, PluginConfig } from './types';
+import { ParsedInfo, PluginConfig, SendResultStats } from './types';
 import { Context, Logger, Session } from "koishi";
 import { Agent as HttpAgent } from 'http';
 import { Agent as HttpsAgent } from 'https';
@@ -19,5 +19,5 @@ export declare function getEffectiveSettings(ctx: Context, guildId: string | und
     nsfw: boolean;
 }>;
 export declare function isUserAdmin(session: Session, userId: string): Promise<boolean>;
-export declare function sendResult_plain(ctx: Context, session: Session, config: PluginConfig, result: ParsedInfo, logger: Logger): Promise<void>;
-export declare function sendResult_forward(ctx: Context, session: Session, config: PluginConfig, result: ParsedInfo, logger: Logger, mixed_sending?: boolean): Promise<void>;
+export declare function sendResult_plain(ctx: Context, session: Session, config: PluginConfig, result: ParsedInfo, logger: Logger): Promise<SendResultStats>;
+export declare function sendResult_forward(ctx: Context, session: Session, config: PluginConfig, result: ParsedInfo, logger: Logger, mixed_sending?: boolean): Promise<SendResultStats>;

package/lib/utils.js

@@ -374,6 +374,8 @@ async function isUserAdmin(session, userId) {
 }
 async function sendResult_plain(ctx, session, config, result, logger) {
     logger.debug('进入普通发送');
+    let downloadTime = 0; // 下载耗时计时
+    let sendTime = 0; // 发送耗时计时
     const localDownloadDir = config.localDownloadDir;
     const onebotReadDir = config.onebotReadDir;
     let mediaCoverUrl = result.coverUrl;
@@ -386,6 +388,7 @@ async function sendResult_plain(ctx, session, config, result, logger) {
     // --- 下载封面 ---
     if (result.coverUrl) {
         if (config.usingLocal) {
+            const t = Date.now(); // 计时开始
             try {
                 mediaCoverUrl = await downloadAndMapUrl(ctx, result.coverUrl, proxy, config.userAgent, localDownloadDir, onebotReadDir, logger, config.enableCache);
                 logger.debug(`封面已下载: ${mediaCoverUrl}`);
@@ -394,13 +397,15 @@ async function sendResult_plain(ctx, session, config, result, logger) {
                 logger.warn(`封面下载失败: ${result.coverUrl}`, e);
                 mediaCoverUrl = result.coverUrl;
             }
+            downloadTime += Date.now() - t; // 累加耗时
         }
         else {
             mediaCoverUrl = result.coverUrl;
         }
     }
     // --- 下载 mainbody 中的图片 ---
-    if (result.mainbody) {
+    if (result.mainbody && config.usingLocal) {
+        const t = Date.now(); // 计时开始
         const imgMatches = [...result.mainbody.matchAll(/<img\s[^>]*src\s*=\s*["']?([^"'>\s]+)["']?/gi)];
         const urlMap = {};
         await Promise.all(imgMatches.map(async (match) => {
@@ -419,6 +424,7 @@ async function sendResult_plain(ctx, session, config, result, logger) {
                 urlMap[remoteUrl] = remoteUrl;
             }
         }));
+        downloadTime += Date.now() - t; // 累加耗时
         mediaMainbody = result.mainbody;
         for (const [remote, local] of Object.entries(urlMap)) {
             const escaped = remote.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
@@ -449,7 +455,9 @@ async function sendResult_plain(ctx, session, config, result, logger) {
                 continue;
             let shouldSend = true;
             if (config.Max_size !== undefined) {
+                const t = Date.now();
                 const sizeBytes = await getFileSize(remoteUrl, proxy, config.userAgent, logger);
+                downloadTime += Date.now() - t;
                 const maxBytes = config.Max_size * 1024 * 1024;
                 if (sizeBytes !== null && sizeBytes > maxBytes) {
                     shouldSend = false;
@@ -457,13 +465,17 @@ async function sendResult_plain(ctx, session, config, result, logger) {
                     const maxMB = config.Max_size.toFixed(2);
                     sendPromises.push(session.send(`文件大小超限 (${sizeMB} MB > ${maxMB} MB)`));
                     logger.info(`文件大小超限 (${sizeMB} MB > ${maxMB} MB)，跳过: ${remoteUrl}`);
+                    sendPromises.push(session.send(`文件大小超限...`));
                 }
             }
             if (shouldSend) {
                 try {
                     let localUrl = remoteUrl;
-                    if (config.usingLocal)
+                    if (config.usingLocal) {
+                        const t = Date.now();
                         localUrl = await downloadAndMapUrl(ctx, remoteUrl, proxy, config.userAgent, localDownloadDir, onebotReadDir, logger, config.enableCache);
+                        downloadTime += Date.now() - t;
+                    }
                     if (!localUrl)
                         continue;
                     let element = null;
@@ -492,10 +504,15 @@ async function sendResult_plain(ctx, session, config, result, logger) {
             }
         }
     }
+    const tSend = Date.now(); // 发送计时开始
     await Promise.all(sendPromises);
+    sendTime = Date.now() - tSend; // 计算发送耗时
+    return { downloadTime, sendTime }; // 返回统计
 }
 async function sendResult_forward(ctx, session, config, result, logger, mixed_sending = false) {
     logger.debug(mixed_sending ? '进入混合发送' : '进入合并发送');
+    let downloadTime = 0;
+    let sendTime = 0;
     const localDownloadDir = config.localDownloadDir;
     const onebotReadDir = config.onebotReadDir;
     let mediaCoverUrl = result.coverUrl;
@@ -508,6 +525,7 @@ async function sendResult_forward(ctx, session, config, result, logger, mixed_se
     // --- 封面 ---
     if (result.coverUrl) {
         if (config.usingLocal) {
+            const t = Date.now();
             try {
                 mediaCoverUrl = await downloadAndMapUrl(ctx, result.coverUrl, proxy, config.userAgent, localDownloadDir, onebotReadDir, logger, config.enableCache);
             }
@@ -515,6 +533,7 @@ async function sendResult_forward(ctx, session, config, result, logger, mixed_se
                 logger.warn('封面下载失败', e);
                 mediaCoverUrl = '';
             }
+            downloadTime += Date.now() - t;
         }
         else {
             mediaCoverUrl = result.coverUrl;
@@ -526,12 +545,14 @@ async function sendResult_forward(ctx, session, config, result, logger, mixed_se
         const urlMap = {};
         await Promise.all(imgUrls.map(async (url) => {
             if (config.usingLocal) {
+                const t = Date.now();
                 try {
                     urlMap[url] = await downloadAndMapUrl(ctx, url, proxy, config.userAgent, localDownloadDir, onebotReadDir, logger, config.enableCache);
                 }
                 catch (e) {
                     logger.warn(`正文图片下载失败: ${url}`, e);
                 }
+                downloadTime += Date.now() - t;
             }
             else {
                 urlMap[url] = url;
@@ -600,7 +621,9 @@ async function sendResult_forward(ctx, session, config, result, logger, mixed_se
                 continue;
             let shouldInclude = true;
             if (config.Max_size !== undefined) {
+                const t = Date.now();
                 const sizeBytes = await getFileSize(remoteUrl, proxy, config.userAgent, logger);
+                downloadTime += Date.now() - t;
                 const maxBytes = config.Max_size * 1024 * 1024;
                 if (sizeBytes !== null && sizeBytes > maxBytes) {
                     shouldInclude = false;
@@ -624,8 +647,11 @@ async function sendResult_forward(ctx, session, config, result, logger, mixed_se
             if (shouldInclude) {
                 try {
                     let localUrl = remoteUrl;
-                    if (config.usingLocal)
+                    if (config.usingLocal) {
+                        const t = Date.now();
                         localUrl = await downloadAndMapUrl(ctx, remoteUrl, proxy, config.userAgent, localDownloadDir, onebotReadDir, logger, config.enableCache);
+                        downloadTime += Date.now() - t;
+                    }
                     if (!localUrl)
                         continue;
                     if (!mixed_sending) {
@@ -686,8 +712,9 @@ async function sendResult_forward(ctx, session, config, result, logger, mixed_se
             });
         }
     }
-    if (forwardNodes.length === 0 && extraSendPromises.length === 0)
-        return;
+    if (forwardNodes.length === 0 && extraSendPromises.length === 0) {
+        return { downloadTime, sendTime };
+    }
     logger.debug(`解析结果: \n ${JSON.stringify(result, null, 2)}`);
     if (!(session.onebot && session.onebot._request))
         throw new Error("Onebot is not defined");
@@ -702,8 +729,14 @@ async function sendResult_forward(ctx, session, config, result, logger, mixed_se
             source: result.title || ''
         }));
     }
+    // 混合模式额外消息
     if (mixed_sending && extraSendPromises.length > 0) {
         promises.push(...extraSendPromises);
     }
-    await Promise.all(promises);
+    if (promises.length > 0) {
+        const tSend = Date.now();
+        await Promise.all(promises);
+        sendTime = Date.now() - tSend;
+    }
+    return { downloadTime, sendTime };
 }

package/package.json

@@ -2,7 +2,7 @@
   "name": "koishi-plugin-share-links-analysis",
   "description": "自用插件",
   "license": "MIT",
-  "version": "0.8.1",
+  "version": "0.8.2",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "files": [