mirror of
https://github.com/whyour/qinglong.git
synced 2026-06-13 22:45:10 +08:00
371 lines
12 KiB
TypeScript
371 lines
12 KiB
TypeScript
import { Router, Request, Response, NextFunction } from 'express';
|
|
import { Container } from 'typedi';
|
|
import { fn, col, where, Op } from 'sequelize';
|
|
import { CrontabModel } from '../data/cron';
|
|
import { CrontabStatModel } from '../data/cronStats';
|
|
import dayjs from 'dayjs';
|
|
import os from 'os';
|
|
|
|
const route = Router();
|
|
|
|
export default (app: Router) => {
|
|
app.use('/dashboard', route);
|
|
|
|
route.post('/record', async (req: Request, res: Response) => {
|
|
try {
|
|
const { ref_id, code, elapsed } = req.body;
|
|
if (!ref_id) return res.send({ code: 400, message: 'ref_id required' });
|
|
|
|
const today = dayjs().format('YYYY-MM-DD');
|
|
const isSuccess = code === 0 ? 1 : 0;
|
|
const isFail = code !== 0 ? 1 : 0;
|
|
const elapsedMs = (Number(elapsed) || 0) * 1000;
|
|
|
|
const existing = await CrontabStatModel.findOne({
|
|
where: { ref_id: Number(ref_id), date: today },
|
|
});
|
|
|
|
if (existing) {
|
|
await CrontabStatModel.update(
|
|
{
|
|
run_count: (existing.run_count || 0) + 1,
|
|
success_count: (existing.success_count || 0) + isSuccess,
|
|
fail_count: (existing.fail_count || 0) + isFail,
|
|
total_time: (existing.total_time || 0) + elapsedMs,
|
|
max_time: Math.max(existing.max_time || 0, elapsedMs),
|
|
},
|
|
{ where: { id: existing.id } },
|
|
);
|
|
} else {
|
|
await CrontabStatModel.create({
|
|
ref_id: Number(ref_id),
|
|
date: today,
|
|
run_count: 1,
|
|
success_count: isSuccess,
|
|
fail_count: isFail,
|
|
total_time: elapsedMs,
|
|
max_time: elapsedMs,
|
|
});
|
|
}
|
|
|
|
res.send({ code: 200 });
|
|
} catch (e) {
|
|
res.send({ code: 500 });
|
|
}
|
|
});
|
|
|
|
route.get(
|
|
'/overview',
|
|
async (req: Request, res: Response, next: NextFunction) => {
|
|
try {
|
|
const today = dayjs().format('YYYY-MM-DD');
|
|
|
|
const [total, enabled, disabled, stats] = await Promise.all([
|
|
CrontabModel.count(),
|
|
CrontabModel.count({ where: { isDisabled: 0 } }),
|
|
CrontabModel.count({ where: { isDisabled: 1 } }),
|
|
CrontabStatModel.findOne({
|
|
attributes: [
|
|
[fn('SUM', col('run_count')), 'total_runs'],
|
|
[fn('SUM', col('success_count')), 'total_success'],
|
|
[fn('SUM', col('fail_count')), 'total_fail'],
|
|
[fn('SUM', col('total_time')), 'total_time'],
|
|
],
|
|
where: { date: today },
|
|
raw: true,
|
|
}),
|
|
]);
|
|
|
|
const row = stats as any;
|
|
const totalRuns = Number(row?.total_runs) || 0;
|
|
const totalSuccess = Number(row?.total_success) || 0;
|
|
const totalFail = Number(row?.total_fail) || 0;
|
|
const totalTime = Number(row?.total_time) || 0;
|
|
|
|
res.send({
|
|
code: 200,
|
|
data: {
|
|
total,
|
|
enabled,
|
|
disabled,
|
|
todayRuns: totalRuns,
|
|
todaySuccess: totalSuccess,
|
|
todayFail: totalFail,
|
|
successRate: totalRuns > 0 ? ((totalSuccess / totalRuns) * 100).toFixed(1) : '0',
|
|
avgTime: totalRuns > 0 ? Math.round(totalTime / totalRuns) : 0,
|
|
},
|
|
});
|
|
} catch (e) {
|
|
next(e);
|
|
}
|
|
},
|
|
);
|
|
|
|
route.get(
|
|
'/trend',
|
|
async (req: Request, res: Response, next: NextFunction) => {
|
|
try {
|
|
const days = parseInt(req.query.days as string) || 7;
|
|
const dates: string[] = [];
|
|
for (let i = days - 1; i >= 0; i--) {
|
|
dates.push(dayjs().subtract(i, 'day').format('YYYY-MM-DD'));
|
|
}
|
|
|
|
const rows = (await CrontabStatModel.findAll({
|
|
attributes: [
|
|
'date',
|
|
[fn('SUM', col('run_count')), 'total_runs'],
|
|
[fn('SUM', col('success_count')), 'total_success'],
|
|
[fn('SUM', col('fail_count')), 'total_fail'],
|
|
],
|
|
where: {
|
|
date: { [Op.in]: dates },
|
|
},
|
|
group: ['date'],
|
|
order: [['date', 'ASC']],
|
|
raw: true,
|
|
})) as any[];
|
|
|
|
const dataMap: Record<string, any> = {};
|
|
rows.forEach((r: any) => {
|
|
dataMap[r.date] = {
|
|
total: Number(r.total_runs) || 0,
|
|
success: Number(r.total_success) || 0,
|
|
fail: Number(r.total_fail) || 0,
|
|
};
|
|
});
|
|
|
|
const data = dates.map((d) => ({
|
|
date: dayjs(d).format('MM-DD'),
|
|
...(dataMap[d] || { total: 0, success: 0, fail: 0 }),
|
|
}));
|
|
|
|
res.send({ code: 200, data });
|
|
} catch (e) {
|
|
next(e);
|
|
}
|
|
},
|
|
);
|
|
|
|
route.get(
|
|
'/top-time',
|
|
async (req: Request, res: Response, next: NextFunction) => {
|
|
try {
|
|
const today = dayjs().format('YYYY-MM-DD');
|
|
|
|
const rows = (await CrontabStatModel.findAll({
|
|
attributes: [
|
|
'ref_id',
|
|
[fn('SUM', col('total_time')), 'total_time'],
|
|
[fn('SUM', col('run_count')), 'run_count'],
|
|
[fn('MAX', col('max_time')), 'max_time'],
|
|
],
|
|
where: { date: today, run_count: { [Op.gt]: 0 } },
|
|
group: ['ref_id'],
|
|
order: [[fn('SUM', col('total_time')), 'DESC']],
|
|
limit: 5,
|
|
raw: true,
|
|
})) as any[];
|
|
|
|
const ids = rows.map((r) => Number(r.ref_id));
|
|
const crons = await CrontabModel.findAll({
|
|
where: { id: { [Op.in]: ids } },
|
|
raw: true,
|
|
});
|
|
const nameMap: Record<number, string> = {};
|
|
crons.forEach((c: any) => { nameMap[c.id] = c.name || c.command; });
|
|
|
|
const data = rows.map((r: any, i) => ({
|
|
rank: i + 1,
|
|
name: nameMap[Number(r.ref_id)] || `任务#${r.ref_id}`,
|
|
avgTime: Math.round(Number(r.total_time) / Number(r.run_count)),
|
|
maxTime: Number(r.max_time),
|
|
}));
|
|
|
|
res.send({ code: 200, data });
|
|
} catch (e) {
|
|
next(e);
|
|
}
|
|
},
|
|
);
|
|
|
|
route.get(
|
|
'/top-count',
|
|
async (req: Request, res: Response, next: NextFunction) => {
|
|
try {
|
|
const today = dayjs().format('YYYY-MM-DD');
|
|
|
|
const rows = (await CrontabStatModel.findAll({
|
|
attributes: [
|
|
'ref_id',
|
|
[fn('SUM', col('run_count')), 'run_count'],
|
|
[fn('SUM', col('total_time')), 'total_time'],
|
|
[fn('SUM', col('success_count')), 'success_count'],
|
|
],
|
|
where: { date: today, run_count: { [Op.gt]: 0 } },
|
|
group: ['ref_id'],
|
|
order: [[fn('SUM', col('run_count')), 'DESC']],
|
|
limit: 5,
|
|
raw: true,
|
|
})) as any[];
|
|
|
|
const ids = rows.map((r) => Number(r.ref_id));
|
|
const crons = await CrontabModel.findAll({
|
|
where: { id: { [Op.in]: ids } },
|
|
raw: true,
|
|
});
|
|
const nameMap: Record<number, string> = {};
|
|
crons.forEach((c: any) => { nameMap[c.id] = c.name || c.command; });
|
|
|
|
const data = rows.map((r: any, i) => ({
|
|
rank: i + 1,
|
|
name: nameMap[Number(r.ref_id)] || `任务#${r.ref_id}`,
|
|
runCount: Number(r.run_count),
|
|
avgTime: Math.round(Number(r.total_time) / Number(r.run_count)),
|
|
successRate:
|
|
Number(r.run_count) > 0
|
|
? ((Number(r.success_count) / Number(r.run_count)) * 100).toFixed(1)
|
|
: '0',
|
|
}));
|
|
|
|
res.send({ code: 200, data });
|
|
} catch (e) {
|
|
next(e);
|
|
}
|
|
},
|
|
);
|
|
|
|
route.get(
|
|
'/runtime',
|
|
async (req: Request, res: Response, next: NextFunction) => {
|
|
try {
|
|
const runningCrons = await CrontabModel.findAll({
|
|
where: {
|
|
status: 0, // running
|
|
},
|
|
raw: true,
|
|
});
|
|
|
|
const queuedCrons = await CrontabModel.findAll({
|
|
where: {
|
|
status: 3, // queued
|
|
},
|
|
raw: true,
|
|
});
|
|
|
|
const running = runningCrons.map((c: any) => ({
|
|
id: c.id,
|
|
name: c.name || c.command || `任务#${c.id}`,
|
|
pid: c.pid,
|
|
elapsed: c.last_execution_time
|
|
? Math.floor((Date.now() / 1000) - c.last_execution_time)
|
|
: 0,
|
|
logPath: c.log_path,
|
|
}));
|
|
|
|
const dayAgo = dayjs().subtract(24, 'hour').unix();
|
|
const idleTasks = await CrontabModel.findAll({
|
|
where: {
|
|
isDisabled: 0,
|
|
status: 1,
|
|
last_execution_time: { [Op.lt]: dayAgo },
|
|
},
|
|
order: [['last_execution_time', 'ASC']],
|
|
limit: 5,
|
|
raw: true,
|
|
});
|
|
|
|
res.send({
|
|
code: 200,
|
|
data: {
|
|
runningCount: running.length,
|
|
queuedCount: queuedCrons.length,
|
|
running,
|
|
idleTasks: idleTasks.map((c: any) => ({
|
|
id: c.id,
|
|
name: c.name || c.command || `任务#${c.id}`,
|
|
lastRun: c.last_execution_time
|
|
? dayjs.unix(c.last_execution_time).format('MM-DD HH:mm')
|
|
: '-',
|
|
})),
|
|
},
|
|
});
|
|
} catch (e) {
|
|
next(e);
|
|
}
|
|
},
|
|
);
|
|
|
|
route.get(
|
|
'/labels',
|
|
async (req: Request, res: Response, next: NextFunction) => {
|
|
try {
|
|
const today = dayjs().format('YYYY-MM-DD');
|
|
const [crons, stats] = (await Promise.all([
|
|
CrontabModel.findAll({ where: { isDisabled: 0 }, raw: true }),
|
|
CrontabStatModel.findAll({ where: { date: today }, raw: true }),
|
|
])) as any[];
|
|
|
|
const statMap: Record<number, any> = {};
|
|
stats.forEach((s: any) => { statMap[s.ref_id] = s; });
|
|
|
|
const labelMap: Record<string, { count: number; runs: number; success: number; totalTime: number }> = {};
|
|
crons.forEach((c: any) => {
|
|
let rawLabels = c.labels;
|
|
if (typeof rawLabels === 'string') rawLabels = JSON.parse(rawLabels);
|
|
const labels: string[] = Array.isArray(rawLabels) && rawLabels.length > 0 ? rawLabels : ['未分类'];
|
|
const st = statMap[c.id];
|
|
labels.forEach((label: string) => {
|
|
if (!labelMap[label]) labelMap[label] = { count: 0, runs: 0, success: 0, totalTime: 0 };
|
|
labelMap[label].count += 1;
|
|
if (st) {
|
|
labelMap[label].runs += Number(st.run_count) || 0;
|
|
labelMap[label].success += Number(st.success_count) || 0;
|
|
labelMap[label].totalTime += Number(st.total_time) || 0;
|
|
}
|
|
});
|
|
});
|
|
|
|
const data = Object.entries(labelMap)
|
|
.map(([label, v]) => ({
|
|
label,
|
|
count: v.count,
|
|
todayRuns: v.runs,
|
|
successRate: v.runs > 0 ? ((v.success / v.runs) * 100).toFixed(1) : '0',
|
|
avgTime: v.runs > 0 ? Math.round(v.totalTime / v.runs) : 0,
|
|
}))
|
|
.sort((a, b) => b.todayRuns - a.todayRuns);
|
|
|
|
res.send({ code: 200, data });
|
|
} catch (e) {
|
|
next(e);
|
|
}
|
|
},
|
|
);
|
|
|
|
route.get(
|
|
'/system',
|
|
async (req: Request, res: Response, next: NextFunction) => {
|
|
try {
|
|
const memUsage = process.memoryUsage();
|
|
res.send({
|
|
code: 200,
|
|
data: {
|
|
platform: os.platform(),
|
|
uptime: Math.floor(os.uptime()),
|
|
memTotal: os.totalmem(),
|
|
memFree: os.freemem(),
|
|
memUsagePercent: ((1 - os.freemem() / os.totalmem()) * 100).toFixed(1),
|
|
heapUsed: Math.round(memUsage.heapUsed / 1024 / 1024),
|
|
heapTotal: Math.round(memUsage.heapTotal / 1024 / 1024),
|
|
loadAvg: os.loadavg().map((v) => Number(v.toFixed(2))),
|
|
cpus: os.cpus().length,
|
|
},
|
|
});
|
|
} catch (e) {
|
|
next(e);
|
|
}
|
|
},
|
|
);
|
|
};
|