befly 3.24.18 → 3.24.20

package/apis/tongJi/errorReport.js

@@ -1,8 +1,12 @@
 import { UAParser } from "ua-parser-js";
 
+import errorReportTable from "#root/tables/errorReport.json";
 import { getDateYmdNumber, getTimeBucketStart } from "#root/utils/datetime.js";
 
+import { expireTongJiRedisKeys, getTongJiMonthStartDate, getTongJiWeekStartDate } from "./_tongJi.js";
+
 const VISIT_STATS_BUCKET_MS = 30 * 60 * 1000;
+const ERROR_STATS_REDIS_TTL_SECONDS = 45 * 24 * 60 * 60;
 
 function getErrorReportUaData(ctx) {
     let userAgent = "";
@@ -29,21 +33,69 @@ function getErrorReportUaData(ctx) {
     };
 }
 
+function getErrorStatsPeriodCountKey(periodType, periodValue) {
+    return `error:${periodType}:${periodValue}:count`;
+}
+
+function getErrorStatsDayBucketsKey(bucketDate) {
+    return `error:day:${bucketDate}:buckets`;
+}
+
+function getErrorStatsDayBucketCountKey(bucketDate, bucketTime) {
+    return `error:day:${bucketDate}:bucket:${bucketTime}:count`;
+}
+
+function getErrorStatsDayTypesKey(bucketDate) {
+    return `error:day:${bucketDate}:types`;
+}
+
+function getErrorStatsDayTypeCountKey(bucketDate, errorType) {
+    return `error:day:${bucketDate}:type:${encodeURIComponent(String(errorType || "unknown"))}:count`;
+}
+
+async function updateErrorStatsRedis(befly, now, bucketDate, bucketTime, errorType) {
+    if (!befly.redis) {
+        return;
+    }
+
+    const weekStartDate = getTongJiWeekStartDate(now);
+    const monthStartDate = getTongJiMonthStartDate(now);
+    const dayCountKey = getErrorStatsPeriodCountKey("day", bucketDate);
+    const weekCountKey = getErrorStatsPeriodCountKey("week", weekStartDate);
+    const monthCountKey = getErrorStatsPeriodCountKey("month", monthStartDate);
+    const dayBucketsKey = getErrorStatsDayBucketsKey(bucketDate);
+    const dayBucketCountKey = getErrorStatsDayBucketCountKey(bucketDate, bucketTime);
+    const dayTypesKey = getErrorStatsDayTypesKey(bucketDate);
+    const dayTypeCountKey = getErrorStatsDayTypeCountKey(bucketDate, errorType);
+
+    await befly.redis.incr(dayCountKey);
+    await befly.redis.incr(weekCountKey);
+    await befly.redis.incr(monthCountKey);
+
+    await befly.redis.sadd(dayBucketsKey, [String(bucketTime)]);
+    await befly.redis.incr(dayBucketCountKey);
+
+    await befly.redis.sadd(dayTypesKey, [String(errorType || "unknown")]);
+    await befly.redis.incr(dayTypeCountKey);
+
+    await expireTongJiRedisKeys(befly, [dayCountKey, weekCountKey, monthCountKey, dayBucketsKey, dayBucketCountKey, dayTypesKey, dayTypeCountKey], ERROR_STATS_REDIS_TTL_SECONDS);
+}
+
 export default {
     name: "上报错误报告",
     method: "POST",
     body: "none",
     auth: false,
     fields: {
-        pagePath: { name: "页面路径", input: "string", min: 0, max: 200 },
-        pageName: { name: "页面名称", input: "string", min: 0, max: 100 },
-        source: { name: "来源", input: "string", min: 0, max: 50 },
-        productName: { name: "产品名称", input: "string", min: 0, max: 100 },
-        productCode: { name: "产品代号", input: "string", min: 0, max: 100 },
-        productVersion: { name: "产品版本", input: "string", min: 0, max: 100 },
-        errorType: { name: "错误类型", input: "string", min: 0, max: 50 },
-        message: { name: "错误信息", input: "string", min: 0, max: 500 },
-        detail: { name: "错误详情", input: "string", min: 0, max: 5000 }
+        pagePath: errorReportTable.pagePath,
+        pageName: errorReportTable.pageName,
+        source: errorReportTable.source,
+        productName: errorReportTable.productName,
+        productCode: errorReportTable.productCode,
+        productVersion: errorReportTable.productVersion,
+        errorType: errorReportTable.errorType,
+        message: errorReportTable.message,
+        detail: errorReportTable.detail
     },
     required: [],
     handler: async (befly, ctx) => {
@@ -60,15 +112,15 @@ export default {
                 bucketTime: bucketTime,
                 bucketDate: bucketDate,
                 hitCount: 1,
-                source: ctx.body?.source,
-                productName: ctx.body?.productName || "",
-                productCode: ctx.body?.productCode || "",
-                productVersion: ctx.body?.productVersion || "",
-                pagePath: ctx.body?.pagePath || "",
-                pageName: ctx.body?.pageName || "",
-                errorType: ctx.body?.errorType || "",
-                message: ctx.body?.message || "",
-                detail: ctx.body?.detail || "",
+                source: ctx.body.source || "",
+                productName: ctx.body.productName || "",
+                productCode: ctx.body.productCode || "",
+                productVersion: ctx.body.productVersion || "",
+                pagePath: ctx.body.pagePath || "",
+                pageName: ctx.body.pageName || "",
+                errorType: ctx.body.errorType || "",
+                message: ctx.body.message || "",
+                detail: ctx.body.detail || "",
                 userAgent: uaData.userAgent,
                 browserName: uaData.browserName,
                 browserVersion: uaData.browserVersion,
@@ -82,6 +134,8 @@ export default {
             }
         });
 
+        await updateErrorStatsRedis(befly, now, bucketDate, bucketTime, ctx.body.errorType || "unknown");
+
         return befly.tool.Yes("上报成功", {
             reportTime: now,
             bucketTime: bucketTime,

package/apis/tongJi/errorStats.js

@@ -1,38 +1,152 @@
 import { getDateYmdNumber } from "#root/utils/datetime.js";
 
+import { getTongJiMonthStartDate, getTongJiNumber, getTongJiRecentDateList, getTongJiWeekStartDate } from "./_tongJi.js";
+
 const ERROR_STATS_DAY_LIMIT = 30;
+const ERROR_STATS_FALLBACK_COUNT_KEY = "stats:fallback:errorStats:count";
+const ERROR_STATS_FALLBACK_DAILY_COUNT_KEY_PREFIX = "stats:fallback:errorStats:count:day:";
+const ERROR_STATS_FALLBACK_TTL_SECONDS = 7 * 24 * 60 * 60;
+
+function getErrorStatsFallbackDailyCountKey(bucketDate) {
+    return `${ERROR_STATS_FALLBACK_DAILY_COUNT_KEY_PREFIX}${bucketDate}`;
+}
+
+function getErrorStatsPeriodCountKey(periodType, periodValue) {
+    return `error:${periodType}:${periodValue}:count`;
+}
+
+function getErrorStatsDayBucketsKey(bucketDate) {
+    return `error:day:${bucketDate}:buckets`;
+}
+
+function getErrorStatsDayBucketCountKey(bucketDate, bucketTime) {
+    return `error:day:${bucketDate}:bucket:${bucketTime}:count`;
+}
+
+function getErrorStatsDayTypesKey(bucketDate) {
+    return `error:day:${bucketDate}:types`;
+}
+
+function getErrorStatsDayTypeCountKey(bucketDate, errorType) {
+    return `error:day:${bucketDate}:type:${encodeURIComponent(String(errorType || "unknown"))}:count`;
+}
+
+async function getErrorStatsRedisSummary(befly, periodType, periodValue) {
+    return {
+        count: getTongJiNumber(await befly.redis.getString(getErrorStatsPeriodCountKey(periodType, periodValue)))
+    };
+}
+
+async function getErrorStatsRedisTrend(befly, bucketDate) {
+    const bucketSet = await befly.redis.smembers(getErrorStatsDayBucketsKey(bucketDate));
+    const trend = [];
+
+    for (const bucketTime of bucketSet) {
+        const itemBucketTime = getTongJiNumber(bucketTime);
+
+        trend.push({
+            bucketTime: itemBucketTime,
+            bucketDate: bucketDate,
+            count: getTongJiNumber(await befly.redis.getString(getErrorStatsDayBucketCountKey(bucketDate, itemBucketTime)))
+        });
+    }
+
+    trend.sort((a, b) => a.bucketTime - b.bucketTime);
+    return trend;
+}
+
+async function getErrorStatsRedisDays(befly, recentDateList) {
+    const days = [];
 
-function toNumber(value) {
-    const num = Number(value);
-    if (!Number.isFinite(num)) {
-        return 0;
+    for (const item of recentDateList) {
+        days.push({
+            bucketDate: item,
+            count: getTongJiNumber(await befly.redis.getString(getErrorStatsPeriodCountKey("day", item)))
+        });
     }
 
-    return num;
+    return days;
 }
 
-function getErrorStatsWeekStartDate(timestamp = Date.now()) {
-    const date = Reflect.construct(Date, [timestamp]);
-    const day = date.getDay();
-    const offset = day === 0 ? -6 : 1 - day;
+async function getErrorStatsRedisTopTypes(befly, bucketDate) {
+    const typeSet = await befly.redis.smembers(getErrorStatsDayTypesKey(bucketDate));
+    const topTypes = [];
+
+    for (const errorType of typeSet) {
+        const name = String(errorType || "unknown");
+        const count = getTongJiNumber(await befly.redis.getString(getErrorStatsDayTypeCountKey(bucketDate, name)));
+
+        if (count <= 0) {
+            continue;
+        }
+
+        topTypes.push({
+            errorType: name,
+            count: count
+        });
+    }
+
+    topTypes.sort((a, b) => {
+        if (b.count !== a.count) {
+            return b.count - a.count;
+        }
+
+        return String(a.errorType).localeCompare(String(b.errorType), "zh-CN");
+    });
 
-    return getDateYmdNumber(timestamp + offset * 24 * 60 * 60 * 1000);
+    return topTypes.slice(0, 5);
 }
 
-function getErrorStatsMonthStartDate(timestamp = Date.now()) {
-    const date = Reflect.construct(Date, [timestamp]);
+async function getErrorStatsFromRedis(befly, bucketDate, weekStartDate, monthStartDate, recentDateList) {
+    const todaySummary = await getErrorStatsRedisSummary(befly, "day", bucketDate);
+    const weekSummary = await getErrorStatsRedisSummary(befly, "week", weekStartDate);
+    const monthSummary = await getErrorStatsRedisSummary(befly, "month", monthStartDate);
+    const trend = await getErrorStatsRedisTrend(befly, bucketDate);
+    const days = await getErrorStatsRedisDays(befly, recentDateList);
+    const topTypes = await getErrorStatsRedisTopTypes(befly, bucketDate);
 
-    return getDateYmdNumber(Reflect.construct(Date, [date.getFullYear(), date.getMonth(), 1, 0, 0, 0, 0]).getTime());
+    if (todaySummary.count <= 0 && weekSummary.count <= 0 && monthSummary.count <= 0 && trend.length === 0 && topTypes.length === 0) {
+        return null;
+    }
+
+    return {
+        today: {
+            bucketDate: bucketDate,
+            count: todaySummary.count
+        },
+        week: {
+            startDate: weekStartDate,
+            endDate: bucketDate,
+            count: weekSummary.count
+        },
+        month: {
+            startDate: monthStartDate,
+            endDate: bucketDate,
+            count: monthSummary.count
+        },
+        trend: trend,
+        days: days,
+        topTypes: topTypes
+    };
 }
 
-function getErrorStatsRecentDateList(now = Date.now(), limit = ERROR_STATS_DAY_LIMIT) {
-    const list = [];
+async function incrErrorStatsFallbackCount(befly, bucketDate) {
+    if (!befly.redis) {
+        return;
+    }
+
+    const dailyKey = getErrorStatsFallbackDailyCountKey(bucketDate);
 
-    for (let i = limit - 1; i >= 0; i--) {
-        list.push(getDateYmdNumber(now - i * 24 * 60 * 60 * 1000));
+    if (typeof befly.redis.incrWithExpire === "function") {
+        await befly.redis.incrWithExpire(ERROR_STATS_FALLBACK_COUNT_KEY, ERROR_STATS_FALLBACK_TTL_SECONDS);
+        await befly.redis.incrWithExpire(dailyKey, ERROR_STATS_FALLBACK_TTL_SECONDS);
+        return;
     }
 
-    return list;
+    await befly.redis.incr(ERROR_STATS_FALLBACK_COUNT_KEY);
+    await befly.redis.expire(ERROR_STATS_FALLBACK_COUNT_KEY, ERROR_STATS_FALLBACK_TTL_SECONDS);
+    await befly.redis.incr(dailyKey);
+    await befly.redis.expire(dailyKey, ERROR_STATS_FALLBACK_TTL_SECONDS);
 }
 
 async function getErrorStatsSummary(befly, startDate, endDate) {
@@ -40,7 +154,7 @@ async function getErrorStatsSummary(befly, startDate, endDate) {
     const detail = result.data?.[0] || {};
 
     return {
-        count: toNumber(detail.count)
+        count: getTongJiNumber(detail.count)
     };
 }
 
@@ -56,6 +170,9 @@ export default {
         const tableReady = tableExistsResult.data === true;
         const now = Date.now();
         const bucketDate = getDateYmdNumber(now);
+        const weekStartDate = getTongJiWeekStartDate(now);
+        const monthStartDate = getTongJiMonthStartDate(now);
+        const recentDateList = getTongJiRecentDateList(now, ERROR_STATS_DAY_LIMIT);
 
         if (!tableReady) {
             return befly.tool.Yes("获取成功", {
@@ -64,12 +181,12 @@ export default {
                     count: 0
                 },
                 week: {
-                    startDate: getErrorStatsWeekStartDate(now),
+                    startDate: weekStartDate,
                     endDate: bucketDate,
                     count: 0
                 },
                 month: {
-                    startDate: getErrorStatsMonthStartDate(now),
+                    startDate: monthStartDate,
                     endDate: bucketDate,
                     count: 0
                 },
@@ -79,9 +196,16 @@ export default {
             });
         }
 
-        const weekStartDate = getErrorStatsWeekStartDate(now);
-        const monthStartDate = getErrorStatsMonthStartDate(now);
-        const recentDateList = getErrorStatsRecentDateList(now);
+        if (befly.redis) {
+            const redisResult = await getErrorStatsFromRedis(befly, bucketDate, weekStartDate, monthStartDate, recentDateList);
+
+            if (redisResult) {
+                return befly.tool.Yes("获取成功", redisResult);
+            }
+
+            await incrErrorStatsFallbackCount(befly, bucketDate);
+        }
+
         const todaySummary = await getErrorStatsSummary(befly, bucketDate, bucketDate);
         const weekSummary = await getErrorStatsSummary(befly, weekStartDate, bucketDate);
         const monthSummary = await getErrorStatsSummary(befly, monthStartDate, bucketDate);
@@ -92,9 +216,9 @@ export default {
         const trend = [];
         for (const item of trendRes.data || []) {
             trend.push({
-                bucketTime: toNumber(item.bucketTime),
-                bucketDate: toNumber(item.bucketDate),
-                count: toNumber(item.count)
+                bucketTime: getTongJiNumber(item.bucketTime),
+                bucketDate: getTongJiNumber(item.bucketDate),
+                count: getTongJiNumber(item.count)
             });
         }
 
@@ -108,7 +232,7 @@ export default {
         }
 
         for (const item of daysRes.data || []) {
-            const itemBucketDate = toNumber(item.bucketDate);
+            const itemBucketDate = getTongJiNumber(item.bucketDate);
 
             if (!daysMap.has(itemBucketDate)) {
                 continue;
@@ -116,7 +240,7 @@ export default {
 
             daysMap.set(itemBucketDate, {
                 bucketDate: itemBucketDate,
-                count: toNumber(item.count)
+                count: getTongJiNumber(item.count)
             });
         }
 
@@ -126,7 +250,7 @@ export default {
         for (const item of topTypesRes.data || []) {
             topTypes.push({
                 errorType: String(item.errorType || "unknown"),
-                count: toNumber(item.count)
+                count: getTongJiNumber(item.count)
             });
         }
 

package/apis/tongJi/fallbackReset.js

@@ -0,0 +1,61 @@
+import { getDateYmdNumber } from "#root/utils/datetime.js";
+
+import { getTongJiNumber } from "./_tongJi.js";
+
+const INFO_STATS_FALLBACK_COUNT_KEY = "stats:fallback:infoStats:count";
+const ERROR_STATS_FALLBACK_COUNT_KEY = "stats:fallback:errorStats:count";
+
+function getInfoStatsFallbackDailyCountKey(reportDate) {
+    return `stats:fallback:infoStats:count:day:${reportDate}`;
+}
+
+function getErrorStatsFallbackDailyCountKey(reportDate) {
+    return `stats:fallback:errorStats:count:day:${reportDate}`;
+}
+
+export default {
+    name: "重置统计回退计数",
+    method: "POST",
+    body: "none",
+    auth: true,
+    fields: {},
+    required: [],
+    handler: async (befly) => {
+        if (!befly.redis) {
+            return befly.tool.No("Redis 不可用，无法重置", {
+                reset: false
+            });
+        }
+
+        const reportDate = getDateYmdNumber(Date.now());
+        const infoDailyKey = getInfoStatsFallbackDailyCountKey(reportDate);
+        const errorDailyKey = getErrorStatsFallbackDailyCountKey(reportDate);
+        const resetKeys = [INFO_STATS_FALLBACK_COUNT_KEY, ERROR_STATS_FALLBACK_COUNT_KEY, infoDailyKey, errorDailyKey];
+        const before = {
+            infoStats: getTongJiNumber(await befly.redis.getString(INFO_STATS_FALLBACK_COUNT_KEY)),
+            errorStats: getTongJiNumber(await befly.redis.getString(ERROR_STATS_FALLBACK_COUNT_KEY)),
+            today: {
+                infoStats: getTongJiNumber(await befly.redis.getString(infoDailyKey)),
+                errorStats: getTongJiNumber(await befly.redis.getString(errorDailyKey))
+            }
+        };
+
+        const removedCount = await befly.redis.delBatch(resetKeys);
+
+        return befly.tool.Yes("重置成功", {
+            reset: true,
+            reportDate: reportDate,
+            removedCount: getTongJiNumber(removedCount),
+            keys: resetKeys,
+            before: before,
+            after: {
+                infoStats: 0,
+                errorStats: 0,
+                today: {
+                    infoStats: 0,
+                    errorStats: 0
+                }
+            }
+        });
+    }
+};

package/apis/tongJi/infoReport.js

@@ -1,8 +1,30 @@
 import { UAParser } from "ua-parser-js";
 
+import infoReportTable from "#root/tables/infoReport.json";
 import { getDateYmdNumber } from "#root/utils/datetime.js";
 import { isValidPositiveInt } from "#root/utils/is.js";
 
+import { getTongJiMonthStartDate, getTongJiWeekStartDate } from "./_tongJi.js";
+
+const INFO_STATS_REDIS_TTL_SECONDS = 45 * 24 * 60 * 60;
+const INFO_STATS_FIELDS = [
+    { key: "sources", valueKey: "source" },
+    { key: "productNames", valueKey: "productName" },
+    { key: "productCodes", valueKey: "productCode" },
+    { key: "productVersions", valueKey: "productVersion" },
+    { key: "pagePaths", valueKey: "pagePath" },
+    { key: "pageNames", valueKey: "pageName" },
+    { key: "deviceTypes", valueKey: "deviceType" },
+    { key: "browsers", valueKey: "browserName" },
+    { key: "browserVersions", valueKey: "browserVersion" },
+    { key: "osList", valueKey: "osName" },
+    { key: "osVersions", valueKey: "osVersion" },
+    { key: "deviceVendors", valueKey: "deviceVendor" },
+    { key: "deviceModels", valueKey: "deviceModel" },
+    { key: "engines", valueKey: "engineName" },
+    { key: "cpuArchitectures", valueKey: "cpuArchitecture" }
+];
+
 function getInfoStatsMember(ctx) {
     if (isValidPositiveInt(ctx.userId)) {
         return `user:${ctx.userId}`;
@@ -11,19 +33,66 @@ function getInfoStatsMember(ctx) {
     return `ip:${ctx.ip || "unknown"}`;
 }
 
+function getInfoStatsNamesKey(periodType, periodValue, fieldKey) {
+    return `info:${periodType}:${periodValue}:${fieldKey}:names`;
+}
+
+function getInfoStatsCountKey(periodType, periodValue, fieldKey, value) {
+    return `info:${periodType}:${periodValue}:${fieldKey}:count:${encodeURIComponent(String(value || ""))}`;
+}
+
+function getInfoStatsReportTimeKey(periodType, periodValue) {
+    return `info:${periodType}:${periodValue}:reportTime`;
+}
+
+async function updateInfoStatsPeriodRedis(befly, periodType, periodValue, statData, now) {
+    const reportTimeKey = getInfoStatsReportTimeKey(periodType, periodValue);
+    await befly.redis.setString(reportTimeKey, String(now), INFO_STATS_REDIS_TTL_SECONDS);
+    await befly.redis.expire(reportTimeKey, INFO_STATS_REDIS_TTL_SECONDS);
+
+    for (const item of INFO_STATS_FIELDS) {
+        const rawValue = String(statData[item.valueKey] || "").trim();
+
+        if (!rawValue) {
+            continue;
+        }
+
+        const namesKey = getInfoStatsNamesKey(periodType, periodValue, item.key);
+        const countKey = getInfoStatsCountKey(periodType, periodValue, item.key, rawValue);
+
+        await befly.redis.sadd(namesKey, [rawValue]);
+        await befly.redis.incr(countKey);
+        await befly.redis.expire(namesKey, INFO_STATS_REDIS_TTL_SECONDS);
+        await befly.redis.expire(countKey, INFO_STATS_REDIS_TTL_SECONDS);
+    }
+}
+
+async function updateInfoStatsRedis(befly, now, reportDate, statData) {
+    if (!befly.redis) {
+        return;
+    }
+
+    const weekStartDate = getTongJiWeekStartDate(now);
+    const monthStartDate = getTongJiMonthStartDate(now);
+
+    await updateInfoStatsPeriodRedis(befly, "day", reportDate, statData, now);
+    await updateInfoStatsPeriodRedis(befly, "week", weekStartDate, statData, now);
+    await updateInfoStatsPeriodRedis(befly, "month", monthStartDate, statData, now);
+}
+
 export default {
     name: "上报访问信息统计",
     method: "POST",
     body: "none",
     auth: false,
     fields: {
-        pagePath: { name: "页面路径", input: "string", min: 0, max: 200 },
-        pageName: { name: "页面名称", input: "string", min: 0, max: 100 },
-        source: { name: "来源", input: "string", min: 0, max: 50 },
-        productName: { name: "产品名称", input: "string", min: 0, max: 100 },
-        productCode: { name: "产品代号", input: "string", min: 0, max: 100 },
-        productVersion: { name: "产品版本", input: "string", min: 0, max: 100 },
-        detail: { name: "扩展详情", input: "string", min: 0, max: 5000 }
+        pagePath: infoReportTable.pagePath,
+        pageName: infoReportTable.pageName,
+        source: infoReportTable.source,
+        productName: infoReportTable.productName,
+        productCode: infoReportTable.productCode,
+        productVersion: infoReportTable.productVersion,
+        detail: infoReportTable.detail
     },
     required: [],
     handler: async (befly, ctx) => {
@@ -31,7 +100,6 @@ export default {
         const reportDate = getDateYmdNumber(now);
         const member = getInfoStatsMember(ctx);
         const tableReady = (await befly.mysql.tableExists("beflyInfoReport")).data === true;
-        const body = ctx.body || {};
         let userAgent = "";
 
         if (!tableReady) {
@@ -68,32 +136,52 @@ export default {
             });
         }
 
+        const statData = {
+            source: ctx.body.source || "",
+            productName: ctx.body.productName || "",
+            productCode: ctx.body.productCode || "",
+            productVersion: ctx.body.productVersion || "",
+            pagePath: ctx.body.pagePath || "",
+            pageName: ctx.body.pageName || "",
+            deviceType: uaResult.device.type || "desktop",
+            browserName: uaResult.browser.name || "",
+            browserVersion: uaResult.browser.version || "",
+            osName: uaResult.os.name || "",
+            osVersion: uaResult.os.version || "",
+            deviceVendor: uaResult.device.vendor || "",
+            deviceModel: uaResult.device.model || "",
+            engineName: uaResult.engine.name || "",
+            cpuArchitecture: uaResult.cpu.architecture || ""
+        };
+
         await befly.mysql.insData({
             table: "beflyInfoReport",
             data: {
                 reportTime: now,
                 reportDate: reportDate,
                 memberKey: member,
-                source: body.source || "",
-                productName: body.productName || "",
-                productCode: body.productCode || "",
-                productVersion: body.productVersion || "",
-                pagePath: body.pagePath || "",
-                pageName: body.pageName || "",
-                detail: body.detail || "",
+                source: statData.source,
+                productName: statData.productName,
+                productCode: statData.productCode,
+                productVersion: statData.productVersion,
+                pagePath: statData.pagePath,
+                pageName: statData.pageName,
+                detail: ctx.body.detail || "",
                 userAgent: userAgent,
-                deviceType: uaResult.device.type || "desktop",
-                browserName: uaResult.browser.name || "",
-                browserVersion: uaResult.browser.version || "",
-                osName: uaResult.os.name || "",
-                osVersion: uaResult.os.version || "",
-                deviceVendor: uaResult.device.vendor || "",
-                deviceModel: uaResult.device.model || "",
-                engineName: uaResult.engine.name || "",
-                cpuArchitecture: uaResult.cpu.architecture || ""
+                deviceType: statData.deviceType,
+                browserName: statData.browserName,
+                browserVersion: statData.browserVersion,
+                osName: statData.osName,
+                osVersion: statData.osVersion,
+                deviceVendor: statData.deviceVendor,
+                deviceModel: statData.deviceModel,
+                engineName: statData.engineName,
+                cpuArchitecture: statData.cpuArchitecture
             }
         });
 
+        await updateInfoStatsRedis(befly, now, reportDate, statData);
+
         return befly.tool.Yes("上报成功", {
             reportTime: now,
             reportDate: reportDate,