增加log采集和管理

.gitignore

@@ -34,3 +34,5 @@ src/web_crawler/Throne-of-Magical-Arcana/Throne-of-Magical-Arcana.txt
 src/web_crawler/Throne-of-Magical-Arcana/Throne-of-Magical-Arcana.epub
 __pycache__/
 *.py[cod]
+.pm2-error-log-cursors.json
+.error-log-poll-state.json

README.md

@@ -49,6 +49,12 @@ npm install
 mysql -u root -p < doc/init.sql
 ```
 
+错误日志表可以手动初始化，也会在服务启动后自动尝试创建:
+
+```bash
+mysql -u root -p kylx365_db < doc/system_error_logs.sql
+```
+
 ## 环境变量
 
 可以通过环境变量自定义配置:
@@ -59,6 +65,12 @@ mysql -u root -p < doc/init.sql
 - `DB_USER`: 数据库用户名
 - `DB_PASSWORD`: 数据库密码
 - `DB_NAME`: 数据库名称
+- `INTERNAL_API_TOKEN`: 内部错误日志 API token，生产环境必须配置
+- `ERROR_LOG_CAPTURE_CONSOLE`: 是否采集 `console.error`，默认 `true`
+- `ERROR_LOG_EXIT_ON_FATAL`: 捕获进程级 fatal error 后是否退出交给 PM2 重启，默认 `true`
+- `ERROR_LOG_API_URL`: 本机轮询脚本访问的错误日志 API 地址
+- `ERROR_LOG_API_TOKEN`: 本机轮询脚本使用的内部 token
+- `ERROR_LOG_START_FROM_BEGINNING`: 本机轮询脚本首次运行时是否从 ID 0 拉取历史错误，默认 `false`
 
 ## 运行
 
@@ -68,6 +80,19 @@ npm run dev
 
 # 生产环境
 npm run start
+
+# 服务器上采集 PM2 error log
+npm run error-log:pm2
+
+# 本机轮询内部错误日志 API
+ERROR_LOG_API_URL=https://your-domain/internal/error-logs ERROR_LOG_API_TOKEN=your-token npm run error-log:poll
+```
+
+内部错误日志接口:
+
+```bash
+curl -H "x-internal-token: your-token" "http://localhost:3050/internal/error-logs?since_id=0&status=all"
+curl -H "x-internal-token: your-token" -X POST "http://localhost:3050/internal/error-logs/1/mark-fixed"
 ```
 
 ## API端点
@@ -79,4 +104,4 @@ npm run start
 
 ```bash
 curl http://localhost:3000/api/Ping
-```
+```

doc/system_error_logs.sql

@@ -0,0 +1,36 @@
+CREATE TABLE IF NOT EXISTS SystemErrorLogs (
+  ID BIGINT UNSIGNED NOT NULL AUTO_INCREMENT,
+  AppName VARCHAR(100) NOT NULL DEFAULT 'miaoguo_system_server',
+  Env VARCHAR(32) NULL,
+  Host VARCHAR(128) NULL,
+  PM2Process VARCHAR(128) NULL,
+  PID INT NULL,
+  Level VARCHAR(32) NOT NULL DEFAULT 'error',
+  Source VARCHAR(64) NOT NULL DEFAULT 'application',
+  Message VARCHAR(1024) NOT NULL,
+  Stack MEDIUMTEXT NULL,
+  FilePath VARCHAR(512) NULL,
+  LineNumber INT NULL,
+  ColumnNumber INT NULL,
+  RequestMethod VARCHAR(16) NULL,
+  RequestUrl VARCHAR(2048) NULL,
+  RequestQuery MEDIUMTEXT NULL,
+  RequestBody MEDIUMTEXT NULL,
+  UserID VARCHAR(64) NULL,
+  NodeVersion VARCHAR(32) NULL,
+  GitCommit VARCHAR(64) NULL,
+  Fingerprint CHAR(64) NOT NULL,
+  Count INT UNSIGNED NOT NULL DEFAULT 1,
+  Status VARCHAR(32) NOT NULL DEFAULT 'open',
+  Extra MEDIUMTEXT NULL,
+  FirstSeenAt DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  LastSeenAt DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  CreateTime DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  UpdateTime DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
+  PRIMARY KEY (ID),
+  UNIQUE KEY uk_SystemErrorLogs_Fingerprint (Fingerprint),
+  KEY idx_SystemErrorLogs_Status_LastSeenAt (Status, LastSeenAt),
+  KEY idx_SystemErrorLogs_LastSeenAt (LastSeenAt),
+  KEY idx_SystemErrorLogs_Source (Source),
+  KEY idx_SystemErrorLogs_FilePath (FilePath(191))
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

package.json

@@ -13,6 +13,8 @@
     "start": "./scripts/use-node-version.sh cross-env NODE_ENV=production node src/app.js",
     "prebuild": "node scripts/check-node-version.js",
     "build": "./scripts/use-node-version.sh cross-env NODE_ENV=production node src/build.js",
+    "error-log:pm2": "./scripts/use-node-version.sh node scripts/collect-pm2-error-logs.js",
+    "error-log:poll": "./scripts/use-node-version.sh node scripts/poll-error-logs.js",
     "test": "./scripts/use-node-version.sh node",
     "node": "./scripts/use-node-version.sh node",
     "check-version": "./scripts/use-node-version.sh node -v"

scripts/collect-pm2-error-logs.js

@@ -0,0 +1,143 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import fsp from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { recordError } from '../src/util/errorLogger.js';
+
+const logDir = process.env.PM2_ERROR_LOG_DIR || path.join(os.homedir(), '.pm2', 'logs');
+const stateFile = process.env.PM2_ERROR_LOG_STATE_FILE || path.join(process.cwd(), '.pm2-error-log-cursors.json');
+const pollIntervalMs = Number(process.env.PM2_ERROR_LOG_POLL_INTERVAL_MS || 30000);
+const readExisting = process.env.PM2_ERROR_LOG_READ_EXISTING === 'true';
+
+async function loadState() {
+  try {
+    return JSON.parse(await fsp.readFile(stateFile, 'utf8'));
+  } catch (error) {
+    return {};
+  }
+}
+
+async function saveState(state) {
+  await fsp.writeFile(stateFile, JSON.stringify(state, null, 2));
+}
+
+async function listPm2ErrorLogs() {
+  try {
+    const files = await fsp.readdir(logDir);
+    return files
+      .filter((file) => file.endsWith('-error.log'))
+      .map((file) => path.join(logDir, file));
+  } catch (error) {
+    console.error(`[pm2-error-log-collector] cannot read log dir ${logDir}:`, error.message || error);
+    return [];
+  }
+}
+
+async function readRange(filePath, start, end) {
+  if (end < start) {
+    return '';
+  }
+
+  let content = '';
+  const stream = fs.createReadStream(filePath, {
+    start,
+    end,
+    encoding: 'utf8',
+  });
+
+  for await (const chunk of stream) {
+    content += chunk;
+  }
+
+  return content;
+}
+
+function splitErrorBlocks(content) {
+  const lines = content.replace(/\r\n/g, '\n').split('\n');
+  const blocks = [];
+  let current = [];
+
+  const startsNewBlock = (line) => {
+    return (
+      /^\d{4}-\d{2}-\d{2}[ T]\d{2}:\d{2}:\d{2}/.test(line) ||
+      /^(Error|TypeError|ReferenceError|SyntaxError|RangeError|UnhandledPromiseRejection|uncaughtException|unhandledRejection)\b/.test(line)
+    );
+  };
+
+  for (const line of lines) {
+    if (startsNewBlock(line) && current.length > 0) {
+      blocks.push(current.join('\n').trim());
+      current = [];
+    }
+    current.push(line);
+  }
+
+  if (current.length > 0) {
+    blocks.push(current.join('\n').trim());
+  }
+
+  return blocks.filter(Boolean);
+}
+
+function getMessageFromBlock(block) {
+  const line = block
+    .split('\n')
+    .map((item) => item.trim())
+    .find((item) => item && !item.startsWith('at '));
+
+  return line
+    ? line.replace(/^\d{4}-\d{2}-\d{2}[ T]\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:?\d{2})?\s*/, '')
+    : 'PM2 error log';
+}
+
+async function collectOnce(state) {
+  const files = await listPm2ErrorLogs();
+
+  for (const filePath of files) {
+    let stat;
+    try {
+      stat = await fsp.stat(filePath);
+    } catch (error) {
+      continue;
+    }
+
+    const previousOffset = state[filePath];
+    if (previousOffset === undefined && !readExisting) {
+      state[filePath] = stat.size;
+      continue;
+    }
+
+    const start = Math.min(previousOffset || 0, stat.size);
+    const content = await readRange(filePath, start, stat.size - 1);
+    state[filePath] = stat.size;
+
+    for (const block of splitErrorBlocks(content)) {
+      await recordError(new Error(getMessageFromBlock(block)), null, {
+        source: 'pm2-log',
+        stack: block,
+        message: getMessageFromBlock(block),
+        extra: { logFile: filePath },
+      });
+    }
+  }
+
+  await saveState(state);
+}
+
+async function main() {
+  console.log(`[pm2-error-log-collector] watching ${logDir}`);
+  const state = await loadState();
+
+  await collectOnce(state);
+  setInterval(() => {
+    collectOnce(state).catch((error) => {
+      console.error('[pm2-error-log-collector] collect failed:', error);
+    });
+  }, pollIntervalMs);
+}
+
+main().catch((error) => {
+  console.error('[pm2-error-log-collector] fatal:', error);
+  process.exit(1);
+});

scripts/poll-error-logs.js

@@ -0,0 +1,136 @@
+#!/usr/bin/env node
+import fsp from 'node:fs/promises';
+import path from 'node:path';
+import { execFile } from 'node:child_process';
+
+const apiUrl = process.env.ERROR_LOG_API_URL || 'http://127.0.0.1:3050/internal/error-logs';
+const token = process.env.ERROR_LOG_API_TOKEN || process.env.INTERNAL_API_TOKEN || '';
+const stateFile = process.env.ERROR_LOG_POLL_STATE_FILE || path.join(process.cwd(), '.error-log-poll-state.json');
+const pollIntervalMs = Number(process.env.ERROR_LOG_POLL_INTERVAL_MS || 60000);
+const limit = Number(process.env.ERROR_LOG_POLL_LIMIT || 50);
+const enableNotify = process.env.ERROR_LOG_NOTIFY === 'true';
+const startFromBeginning = process.env.ERROR_LOG_START_FROM_BEGINNING === 'true';
+
+async function loadState() {
+  try {
+    return {
+      isNew: false,
+      state: JSON.parse(await fsp.readFile(stateFile, 'utf8')),
+    };
+  } catch (error) {
+    return {
+      isNew: true,
+      state: {
+        sinceId: process.env.ERROR_LOG_SINCE_ID === undefined ? null : Number(process.env.ERROR_LOG_SINCE_ID || 0),
+      },
+    };
+  }
+}
+
+async function saveState(state) {
+  await fsp.writeFile(stateFile, JSON.stringify(state, null, 2));
+}
+
+function formatLog(item) {
+  const location = item.FilePath ? `${item.FilePath}:${item.LineNumber || 0}:${item.ColumnNumber || 0}` : 'unknown location';
+  const request = item.RequestUrl ? ` ${item.RequestMethod || 'REQUEST'} ${item.RequestUrl}` : '';
+  return [
+    `[${item.ID}] ${item.Source} ${item.Status} x${item.Count}`,
+    item.Message,
+    location,
+    request.trim(),
+  ].filter(Boolean).join('\n');
+}
+
+function notify(item) {
+  if (!enableNotify || process.platform !== 'darwin') {
+    return;
+  }
+
+  const title = `New ${item.Source} error #${item.ID}`;
+  const message = String(item.Message || '').replace(/"/g, '\\"').slice(0, 180);
+
+  execFile('osascript', [
+    '-e',
+    `display notification "${message}" with title "${title}"`,
+  ]);
+}
+
+function buildApiUrl({ sinceId = 0, latest = false } = {}) {
+  const url = new URL(apiUrl);
+  if (latest) {
+    url.pathname = url.pathname.replace(/\/$/, '') + '/latest';
+  } else {
+    url.searchParams.set('since_id', sinceId);
+  }
+  url.searchParams.set('status', 'all');
+  url.searchParams.set('limit', limit);
+  return url;
+}
+
+async function fetchErrorLogs(url) {
+  if (!token) {
+    throw new Error('ERROR_LOG_API_TOKEN or INTERNAL_API_TOKEN is required');
+  }
+
+  const response = await fetch(url, {
+    headers: {
+      'x-internal-token': token,
+    },
+  });
+
+  if (!response.ok) {
+    throw new Error(`HTTP ${response.status}: ${await response.text()}`);
+  }
+
+  const data = await response.json();
+  if (data.errcode !== 10000) {
+    throw new Error(data.errMsg || `Unexpected response: ${JSON.stringify(data)}`);
+  }
+
+  return data.result?.list || [];
+}
+
+async function fetchLatestSinceId() {
+  const list = await fetchErrorLogs(buildApiUrl({ latest: true }));
+  return list.reduce((maxId, item) => Math.max(maxId, Number(item.ID || 0)), 0);
+}
+
+async function pollOnce(state) {
+  const list = await fetchErrorLogs(buildApiUrl({ sinceId: state.sinceId || 0 }));
+  if (list.length === 0) {
+    return;
+  }
+
+  for (const item of list) {
+    console.log('\n' + formatLog(item));
+    notify(item);
+    state.sinceId = Math.max(Number(state.sinceId || 0), Number(item.ID || 0));
+  }
+
+  await saveState(state);
+}
+
+async function main() {
+  const loaded = await loadState();
+  const state = loaded.state;
+
+  if (loaded.isNew && state.sinceId === null) {
+    state.sinceId = startFromBeginning ? 0 : await fetchLatestSinceId();
+    await saveState(state);
+  }
+
+  console.log(`[error-log-poller] polling ${apiUrl} every ${pollIntervalMs}ms from ID ${state.sinceId || 0}`);
+
+  await pollOnce(state);
+  setInterval(() => {
+    pollOnce(state).catch((error) => {
+      console.error('[error-log-poller] poll failed:', error.message || error);
+    });
+  }, pollIntervalMs);
+}
+
+main().catch((error) => {
+  console.error('[error-log-poller] fatal:', error.message || error);
+  process.exit(1);
+});

src/api/internal/errorLogController.js

@@ -0,0 +1,134 @@
+import config from '../../config/index.js';
+import {
+  getErrorLogById,
+  listErrorLogs,
+  updateErrorLogStatus,
+} from '../../model/systemErrorLog.js';
+
+const allowedStatuses = new Set(['open', 'fixed', 'ignored', 'reopened']);
+
+function getInternalToken(ctx) {
+  const authorization = ctx.get('authorization') || '';
+  if (authorization.toLowerCase().startsWith('bearer ')) {
+    return authorization.slice(7).trim();
+  }
+
+  return ctx.get('x-internal-token') || ctx.query.token || ctx.query.internal_token || '';
+}
+
+function parseStatusList(status) {
+  if (!status) {
+    return ['open', 'reopened'];
+  }
+
+  if (String(status).toLowerCase() === 'all') {
+    return null;
+  }
+
+  return String(status)
+    .split(',')
+    .map((item) => item.trim())
+    .filter(Boolean);
+}
+
+function parseLimit(limit) {
+  return Math.min(Math.max(Number(limit) || 50, 1), 200);
+}
+
+export async function requireInternalToken(ctx, next) {
+  if (!config.internalApiToken) {
+    ctx.status = 503;
+    ctx.body = {
+      errcode: 10503,
+      errMsg: 'INTERNAL_API_TOKEN is not configured',
+    };
+    return;
+  }
+
+  if (getInternalToken(ctx) !== config.internalApiToken) {
+    ctx.status = 401;
+    ctx.body = {
+      errcode: 10401,
+      errMsg: 'Unauthorized',
+    };
+    return;
+  }
+
+  await next();
+}
+
+export async function ListErrorLogs(ctx) {
+  const list = await listErrorLogs({
+    sinceId: ctx.query.since_id || ctx.query.sinceId || 0,
+    limit: parseLimit(ctx.query.limit),
+    statusList: parseStatusList(ctx.query.status),
+    source: ctx.query.source || '',
+    fingerprint: ctx.query.fingerprint || '',
+    order: ctx.query.order || 'ASC',
+  });
+
+  const nextSinceId = list.reduce((maxId, item) => Math.max(maxId, Number(item.ID || 0)), Number(ctx.query.since_id || ctx.query.sinceId || 0));
+
+  ctx.body = {
+    errcode: 10000,
+    result: {
+      list,
+      next_since_id: nextSinceId,
+    },
+  };
+}
+
+export async function ListLatestErrorLogs(ctx) {
+  const list = await listErrorLogs({
+    sinceId: 0,
+    limit: parseLimit(ctx.query.limit),
+    statusList: parseStatusList(ctx.query.status),
+    source: ctx.query.source || '',
+    fingerprint: ctx.query.fingerprint || '',
+    order: 'DESC',
+  });
+
+  ctx.body = {
+    errcode: 10000,
+    result: {
+      list,
+      next_since_id: list.reduce((maxId, item) => Math.max(maxId, Number(item.ID || 0)), 0),
+    },
+  };
+}
+
+export async function GetErrorLog(ctx) {
+  const item = await getErrorLogById(ctx.params.id);
+  if (!item) {
+    ctx.status = 404;
+    ctx.body = {
+      errcode: 10404,
+      errMsg: 'Error log not found',
+    };
+    return;
+  }
+
+  ctx.body = {
+    errcode: 10000,
+    result: item,
+  };
+}
+
+export async function UpdateErrorLogStatus(ctx) {
+  const status = ctx.request.body?.status || ctx.query.status || 'fixed';
+
+  if (!allowedStatuses.has(status)) {
+    ctx.status = 400;
+    ctx.body = {
+      errcode: 10400,
+      errMsg: 'Invalid status',
+    };
+    return;
+  }
+
+  await updateErrorLogStatus(ctx.params.id, status);
+
+  ctx.body = {
+    errcode: 10000,
+  };
+}

src/api/internal/routes.js

@@ -0,0 +1,18 @@
+import Router from '@koa/router';
+import {
+  GetErrorLog,
+  ListErrorLogs,
+  ListLatestErrorLogs,
+  UpdateErrorLogStatus,
+  requireInternalToken,
+} from './errorLogController.js';
+
+const router = new Router();
+
+router.get('/internal/error-logs', requireInternalToken, ListErrorLogs);
+router.get('/internal/error-logs/latest', requireInternalToken, ListLatestErrorLogs);
+router.get('/internal/error-logs/:id', requireInternalToken, GetErrorLog);
+router.post('/internal/error-logs/:id/mark-fixed', requireInternalToken, UpdateErrorLogStatus);
+router.post('/internal/error-logs/:id/status', requireInternalToken, UpdateErrorLogStatus);
+
+export default router;

src/app.js

@@ -6,10 +6,12 @@ import path from 'path';
 import { fileURLToPath } from 'url';
 import config from './config/index.js';
 import { decryptUrlMiddle } from './util/crypto/index.js';
+import { registerErrorLogging } from './util/errorLogger.js';
 import { stringUtils } from './util/stringClass.js';
 import xmlBodyParser from './middleware/xmlBodyParser.js';
 import queryParamSanitizer from './middleware/queryParamSanitizer.js';
 
+import internalRouter from './api/internal/routes.js';
 import commonRouter from './api/common/routes.js';
 import mpsRouter from './api/mps/routes.js';
 import yjbdcRouter from './api/yjbdc/routes.js';
@@ -42,13 +44,7 @@ const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
 const app = new Koa();
 
-// 使用中间件
-app.use(xmlBodyParser());
-app.use(bodyParser());
-app.use(queryParamSanitizer());
-
-// 静态文件服务
-app.use(serve(__dirname + '/../public'));
+registerErrorLogging(app);
 
 // 错误处理
 app.use(async (ctx, next) => {
@@ -65,6 +61,14 @@ app.use(async (ctx, next) => {
     }
 });
 
+// 使用中间件
+app.use(xmlBodyParser());
+app.use(bodyParser());
+app.use(queryParamSanitizer());
+
+// 静态文件服务
+app.use(serve(__dirname + '/../public'));
+
 // 设置签名密钥
 app.keys = ['some secret hurr'];
 
@@ -84,6 +88,9 @@ const SessionConfig = {
 // 使用session中间件
 app.use(session(SessionConfig, app));
 
+// 内部运维接口
+app.use(internalRouter.routes());
+app.use(internalRouter.allowedMethods());
 
 //中间件
 app.use(decryptUrlMiddle());

src/config/index.js

@@ -1,9 +1,28 @@
 import devConfig from './dev.js';
 import prodConfig from './prod.js';
 
+if (!process.env.NODE_ENV)
+    process.env.NODE_ENV='development';
+
+const runtimeEnv = process.env.NODE_ENV || 'development';
+const defaultInternalApiToken = runtimeEnv === 'production' ? '' : 'dev-internal-token';
+const toNumber = (value, fallback) => {
+    const number = Number(value);
+    return Number.isFinite(number) ? number : fallback;
+};
+
 // 公共数据库配置
 const commonConfig = {
     port: process.env.PORT || 3000,
+    internalApiToken: process.env.INTERNAL_API_TOKEN || defaultInternalApiToken,
+    errorLogging: {
+        appName: process.env.ERROR_LOG_APP_NAME || 'miaoguo_system_server',
+        captureConsoleError: process.env.ERROR_LOG_CAPTURE_CONSOLE !== 'false',
+        exitOnFatal: process.env.ERROR_LOG_EXIT_ON_FATAL !== 'false',
+        fatalExitDelayMs: toNumber(process.env.ERROR_LOG_FATAL_EXIT_DELAY_MS, 1500),
+        maxPayloadLength: toNumber(process.env.ERROR_LOG_MAX_PAYLOAD_LENGTH, 8000),
+        maxStackLength: toNumber(process.env.ERROR_LOG_MAX_STACK_LENGTH, 30000)
+    },
     CDNUrl: 'https://cdn.example.com/',
     database: {
         multipleStatements: true,
@@ -157,10 +176,7 @@ const commonConfig = {
     ]
 };
 
-if (!process.env.NODE_ENV)
-    process.env.NODE_ENV='development';
-
-const env = process.env.NODE_ENV || 'development';
+const env = runtimeEnv;
 const envConfig = env === 'production' ? prodConfig : devConfig;
 
 // 合并配置，环境特定配置会覆盖公共配置

src/model/systemErrorLog.js

@@ -0,0 +1,151 @@
+import { query } from '../util/db.js';
+
+let ensureTablePromise = null;
+
+export async function ensureSystemErrorLogsTable() {
+  if (!ensureTablePromise) {
+    const sql = `
+      CREATE TABLE IF NOT EXISTS SystemErrorLogs (
+        ID BIGINT UNSIGNED NOT NULL AUTO_INCREMENT,
+        AppName VARCHAR(100) NOT NULL DEFAULT 'miaoguo_system_server',
+        Env VARCHAR(32) NULL,
+        Host VARCHAR(128) NULL,
+        PM2Process VARCHAR(128) NULL,
+        PID INT NULL,
+        Level VARCHAR(32) NOT NULL DEFAULT 'error',
+        Source VARCHAR(64) NOT NULL DEFAULT 'application',
+        Message VARCHAR(1024) NOT NULL,
+        Stack MEDIUMTEXT NULL,
+        FilePath VARCHAR(512) NULL,
+        LineNumber INT NULL,
+        ColumnNumber INT NULL,
+        RequestMethod VARCHAR(16) NULL,
+        RequestUrl VARCHAR(2048) NULL,
+        RequestQuery MEDIUMTEXT NULL,
+        RequestBody MEDIUMTEXT NULL,
+        UserID VARCHAR(64) NULL,
+        NodeVersion VARCHAR(32) NULL,
+        GitCommit VARCHAR(64) NULL,
+        Fingerprint CHAR(64) NOT NULL,
+        Count INT UNSIGNED NOT NULL DEFAULT 1,
+        Status VARCHAR(32) NOT NULL DEFAULT 'open',
+        Extra MEDIUMTEXT NULL,
+        FirstSeenAt DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        LastSeenAt DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        CreateTime DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        UpdateTime DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
+        PRIMARY KEY (ID),
+        UNIQUE KEY uk_SystemErrorLogs_Fingerprint (Fingerprint),
+        KEY idx_SystemErrorLogs_Status_LastSeenAt (Status, LastSeenAt),
+        KEY idx_SystemErrorLogs_LastSeenAt (LastSeenAt),
+        KEY idx_SystemErrorLogs_Source (Source),
+        KEY idx_SystemErrorLogs_FilePath (FilePath(191))
+      ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
+    `;
+
+    ensureTablePromise = query(sql).catch((error) => {
+      ensureTablePromise = null;
+      throw error;
+    });
+  }
+
+  return ensureTablePromise;
+}
+
+export async function upsertErrorLog(log) {
+  await ensureSystemErrorLogsTable();
+
+  const sql = `
+    INSERT INTO SystemErrorLogs SET ?
+    ON DUPLICATE KEY UPDATE
+      AppName=VALUES(AppName),
+      Env=VALUES(Env),
+      Host=VALUES(Host),
+      PM2Process=VALUES(PM2Process),
+      PID=VALUES(PID),
+      Level=VALUES(Level),
+      Source=VALUES(Source),
+      Message=VALUES(Message),
+      Stack=VALUES(Stack),
+      FilePath=VALUES(FilePath),
+      LineNumber=VALUES(LineNumber),
+      ColumnNumber=VALUES(ColumnNumber),
+      RequestMethod=VALUES(RequestMethod),
+      RequestUrl=VALUES(RequestUrl),
+      RequestQuery=VALUES(RequestQuery),
+      RequestBody=VALUES(RequestBody),
+      UserID=VALUES(UserID),
+      NodeVersion=VALUES(NodeVersion),
+      GitCommit=VALUES(GitCommit),
+      Extra=VALUES(Extra),
+      Count=\`Count\` + 1,
+      Status=IF(\`Status\`='fixed', 'reopened', \`Status\`),
+      LastSeenAt=VALUES(LastSeenAt),
+      UpdateTime=NOW()
+  `;
+
+  return await query(sql, [log]);
+}
+
+export async function listErrorLogs(options = {}) {
+  await ensureSystemErrorLogsTable();
+
+  const {
+    sinceId = 0,
+    limit = 50,
+    statusList = ['open', 'reopened'],
+    source,
+    fingerprint,
+    order = 'ASC',
+  } = options;
+
+  const where = ['ID > ?'];
+  const params = [Number(sinceId) || 0];
+
+  if (statusList && statusList.length > 0) {
+    where.push('Status IN (?)');
+    params.push(statusList);
+  }
+
+  if (source) {
+    where.push('Source = ?');
+    params.push(source);
+  }
+
+  if (fingerprint) {
+    where.push('Fingerprint = ?');
+    params.push(fingerprint);
+  }
+
+  params.push(Math.min(Math.max(Number(limit) || 50, 1), 200));
+
+  const orderSql = String(order).toUpperCase() === 'DESC' ? 'DESC' : 'ASC';
+  const sql = `
+    SELECT
+      ID, AppName, Env, Host, PM2Process, PID, Level, Source, Message,
+      Stack, FilePath, LineNumber, ColumnNumber, RequestMethod, RequestUrl,
+      RequestQuery, RequestBody, UserID, NodeVersion, GitCommit, Fingerprint,
+      Count, Status, Extra, FirstSeenAt, LastSeenAt, CreateTime, UpdateTime
+    FROM SystemErrorLogs
+    WHERE ${where.join(' AND ')}
+    ORDER BY ID ${orderSql}
+    LIMIT ?
+  `;
+
+  return await query(sql, params);
+}
+
+export async function getErrorLogById(id) {
+  await ensureSystemErrorLogsTable();
+
+  const sql = 'SELECT * FROM SystemErrorLogs WHERE ID=? LIMIT 1';
+  const rows = await query(sql, [Number(id) || 0]);
+  return rows[0] || null;
+}
+
+export async function updateErrorLogStatus(id, status) {
+  await ensureSystemErrorLogsTable();
+
+  const sql = 'UPDATE SystemErrorLogs SET Status=?, UpdateTime=NOW() WHERE ID=?';
+  return await query(sql, [status, Number(id) || 0]);
+}

src/util/errorLogger.js

@@ -0,0 +1,321 @@
+import os from 'node:os';
+import path from 'node:path';
+import { execSync } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { fileURLToPath } from 'node:url';
+import config from '../config/index.js';
+import {
+  ensureSystemErrorLogsTable,
+  upsertErrorLog,
+} from '../model/systemErrorLog.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const projectRoot = path.resolve(__dirname, '../..');
+const originalConsoleError = console.error.bind(console);
+const sensitiveKeyPattern = /password|passwd|token|secret|authorization|cookie|session|apikey|api_key|access_token|refresh_token/i;
+
+let gitCommitCache;
+let processHandlersRegistered = false;
+let consoleErrorCaptureInstalled = false;
+let fatalExitStarted = false;
+
+function truncateString(value, maxLength) {
+  if (value === null || value === undefined) {
+    return null;
+  }
+
+  const str = String(value);
+  if (str.length <= maxLength) {
+    return str;
+  }
+
+  return `${str.slice(0, maxLength)}... [truncated ${str.length - maxLength} chars]`;
+}
+
+function redactValue(value, depth = 0) {
+  if (depth > 5) {
+    return '[MaxDepth]';
+  }
+
+  if (Array.isArray(value)) {
+    return value.slice(0, 50).map((item) => redactValue(item, depth + 1));
+  }
+
+  if (value && typeof value === 'object') {
+    const result = {};
+    for (const [key, item] of Object.entries(value)) {
+      result[key] = sensitiveKeyPattern.test(key) ? '[REDACTED]' : redactValue(item, depth + 1);
+    }
+    return result;
+  }
+
+  return value;
+}
+
+function stringifyForDb(value, maxLength = config.errorLogging.maxPayloadLength) {
+  if (value === undefined || value === null) {
+    return null;
+  }
+
+  try {
+    return truncateString(JSON.stringify(redactValue(value)), maxLength);
+  } catch (error) {
+    return truncateString(String(value), maxLength);
+  }
+}
+
+function getGitCommit() {
+  if (gitCommitCache !== undefined) {
+    return gitCommitCache;
+  }
+
+  try {
+    gitCommitCache = execSync('git rev-parse --short=12 HEAD', {
+      cwd: projectRoot,
+      stdio: ['ignore', 'pipe', 'ignore'],
+    }).toString().trim();
+  } catch (error) {
+    gitCommitCache = '';
+  }
+
+  return gitCommitCache;
+}
+
+function toError(value) {
+  if (value instanceof Error) {
+    return value;
+  }
+
+  const message = typeof value === 'string' ? value : stringifyForDb(value, 1000) || 'Unknown error';
+  return new Error(message);
+}
+
+function parseStackLocation(stack) {
+  if (!stack) {
+    return {};
+  }
+
+  const lines = String(stack).split('\n');
+  for (const line of lines) {
+    if (
+      line.includes('node:internal') ||
+      line.includes('/node_modules/') ||
+      line.includes('\\node_modules\\') ||
+      line.includes('<anonymous>')
+    ) {
+      continue;
+    }
+
+    const match = line.match(/((?:file:\/\/)?\/[^)\s]+):(\d+):(\d+)/);
+    if (!match) {
+      continue;
+    }
+
+    return {
+      filePath: match[1].replace(/^file:\/\//, ''),
+      lineNumber: Number(match[2]),
+      columnNumber: Number(match[3]),
+    };
+  }
+
+  return {};
+}
+
+function findUserId(value) {
+  if (!value || typeof value !== 'object') {
+    return null;
+  }
+
+  return value.UserID || value.userId || value.userID || value.UserId || value.uid || null;
+}
+
+function normalizeFingerprintText(value) {
+  return String(value || '')
+    .replace(/\d{4}-\d{2}-\d{2}[ T]\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:?\d{2})?/g, '<timestamp>')
+    .replace(/\bpid[:=]\s*\d+\b/gi, 'pid:<number>');
+}
+
+function getRequestInfo(ctx) {
+  if (!ctx) {
+    return {};
+  }
+
+  const query = ctx.query || {};
+  const body = ctx.request?.body || {};
+
+  return {
+    RequestMethod: truncateString(ctx.method, 16),
+    RequestUrl: truncateString(ctx.originalUrl || ctx.url, 2048),
+    RequestQuery: stringifyForDb(query),
+    RequestBody: stringifyForDb(body),
+    UserID: truncateString(findUserId(query) || findUserId(body), 64),
+  };
+}
+
+function makeFingerprint({ source, message, filePath, lineNumber, stack }) {
+  const businessFrame = filePath ? `${filePath}:${lineNumber || 0}` : '';
+  const firstStackLine = stack ? String(stack).split('\n').find((line) => line.trim()) : '';
+  const raw = [
+    source || 'application',
+    normalizeFingerprintText(truncateString(message, 500)),
+    businessFrame,
+    normalizeFingerprintText(firstStackLine || ''),
+  ].join('|');
+
+  return createHash('sha256').update(raw).digest('hex');
+}
+
+function getPm2ProcessName() {
+  return (
+    process.env.pm_name ||
+    process.env.name ||
+    process.env.NODE_APP_INSTANCE ||
+    process.env.pm_id ||
+    ''
+  );
+}
+
+function buildLogRecord(errorInput, ctx, options = {}) {
+  const error = toError(errorInput);
+  const stack = truncateString(options.stack || error.stack || '', config.errorLogging.maxStackLength);
+  const message = truncateString(options.message || error.message || String(errorInput), 1024) || 'Unknown error';
+  const location = parseStackLocation(stack);
+  const source = truncateString(options.source || 'application', 64);
+  const now = new Date();
+
+  const record = {
+    AppName: truncateString(config.errorLogging.appName, 100),
+    Env: truncateString(process.env.NODE_ENV || 'development', 32),
+    Host: truncateString(os.hostname(), 128),
+    PM2Process: truncateString(getPm2ProcessName(), 128),
+    PID: process.pid,
+    Level: truncateString(options.level || 'error', 32),
+    Source: source,
+    Message: message,
+    Stack: stack,
+    FilePath: truncateString(location.filePath || options.filePath || '', 512),
+    LineNumber: location.lineNumber || options.lineNumber || null,
+    ColumnNumber: location.columnNumber || options.columnNumber || null,
+    NodeVersion: truncateString(process.version, 32),
+    GitCommit: truncateString(getGitCommit(), 64),
+    LastSeenAt: now,
+    Extra: stringifyForDb(options.extra || null),
+    ...getRequestInfo(ctx),
+  };
+
+  record.Fingerprint = makeFingerprint({
+    source,
+    message,
+    stack,
+    filePath: record.FilePath,
+    lineNumber: record.LineNumber,
+  });
+
+  return record;
+}
+
+export async function recordError(errorInput, ctx = null, options = {}) {
+  try {
+    const record = buildLogRecord(errorInput, ctx, options);
+    return await upsertErrorLog(record);
+  } catch (error) {
+    originalConsoleError('[errorLogger] failed to record error:', error);
+    return null;
+  }
+}
+
+function normalizeConsoleErrorArgs(args) {
+  const firstError = args.find((arg) => arg instanceof Error);
+  const stack = firstError?.stack || args.map((arg) => (arg instanceof Error ? arg.stack : String(arg))).join('\n');
+  const message = args.map((arg) => {
+    if (arg instanceof Error) {
+      return arg.message;
+    }
+    if (typeof arg === 'string') {
+      return arg;
+    }
+    return stringifyForDb(arg, 1000);
+  }).filter(Boolean).join(' ');
+
+  return {
+    message: truncateString(message || 'console.error', 1024),
+    stack: truncateString(stack, config.errorLogging.maxStackLength),
+  };
+}
+
+export function installConsoleErrorCapture() {
+  if (consoleErrorCaptureInstalled) {
+    return;
+  }
+
+  consoleErrorCaptureInstalled = true;
+  console.error = (...args) => {
+    originalConsoleError(...args);
+
+    const normalized = normalizeConsoleErrorArgs(args);
+    void recordError(new Error(normalized.message), null, {
+      source: 'console.error',
+      stack: normalized.stack,
+      message: normalized.message,
+      extra: { args: normalized.message },
+    });
+  };
+}
+
+function scheduleFatalExit() {
+  if (!config.errorLogging.exitOnFatal || fatalExitStarted) {
+    return;
+  }
+
+  fatalExitStarted = true;
+  const timer = setTimeout(() => {
+    process.exit(1);
+  }, config.errorLogging.fatalExitDelayMs);
+
+  timer.unref();
+}
+
+async function handleFatalProcessError(errorInput, source) {
+  const error = toError(errorInput);
+  originalConsoleError(`[${source}]`, error);
+  scheduleFatalExit();
+
+  await recordError(error, null, {
+    source,
+    level: 'fatal',
+  });
+
+  if (config.errorLogging.exitOnFatal) {
+    process.exit(1);
+  }
+}
+
+export function registerErrorLogging(app) {
+  if (processHandlersRegistered) {
+    return;
+  }
+
+  processHandlersRegistered = true;
+
+  ensureSystemErrorLogsTable().catch((error) => {
+    originalConsoleError('[errorLogger] failed to ensure SystemErrorLogs table:', error.message || error);
+  });
+
+  if (app) {
+    app.on('error', (error, ctx) => {
+      void recordError(error, ctx, { source: 'koa' });
+    });
+  }
+
+  process.on('unhandledRejection', (reason) => {
+    void handleFatalProcessError(reason, 'unhandledRejection');
+  });
+
+  process.on('uncaughtException', (error) => {
+    void handleFatalProcessError(error, 'uncaughtException');
+  });
+
+  if (config.errorLogging.captureConsoleError) {
+    installConsoleErrorCapture();
+  }
+}