uptime-kuma/server/model/monitor.js

454 lines
16 KiB
JavaScript
Raw Normal View History

2021-07-30 11:18:26 +00:00
const https = require("https");
2021-06-25 13:55:49 +00:00
const dayjs = require("dayjs");
2021-07-30 11:18:26 +00:00
const utc = require("dayjs/plugin/utc")
let timezone = require("dayjs/plugin/timezone")
2021-06-27 08:10:55 +00:00
dayjs.extend(utc)
dayjs.extend(timezone)
const axios = require("axios");
2021-07-30 11:18:26 +00:00
const { Prometheus } = require("../prometheus");
2021-08-16 18:09:40 +00:00
const { debug, UP, DOWN, PENDING, flipStatus, TimeLogger } = require("../../src/util");
2021-08-22 22:05:48 +00:00
const { tcping, ping, dnsResolve, checkCertificate, checkStatusCode } = require("../util-server");
2021-07-30 11:18:26 +00:00
const { R } = require("redbean-node");
const { BeanModel } = require("redbean-node/dist/bean-model");
const { Notification } = require("../notification")
2021-08-12 16:13:46 +00:00
const version = require("../../package.json").version;
2021-06-27 08:10:55 +00:00
/**
* status:
* 0 = DOWN
* 1 = UP
2021-07-27 17:53:59 +00:00
* 2 = PENDING
2021-06-27 08:10:55 +00:00
*/
2021-06-25 13:55:49 +00:00
class Monitor extends BeanModel {
async toJSON() {
let notificationIDList = {};
let list = await R.find("monitor_notification", " monitor_id = ? ", [
2021-07-30 11:18:26 +00:00
this.id,
])
for (let bean of list) {
notificationIDList[bean.notification_id] = true;
}
2021-06-25 13:55:49 +00:00
return {
id: this.id,
name: this.name,
url: this.url,
2021-07-01 06:03:06 +00:00
hostname: this.hostname,
port: this.port,
maxretries: this.maxretries,
2021-07-01 05:11:16 +00:00
weight: this.weight,
2021-06-25 13:55:49 +00:00
active: this.active,
type: this.type,
interval: this.interval,
2021-07-01 09:19:28 +00:00
keyword: this.keyword,
ignoreTls: this.getIgnoreTls(),
upsideDown: this.isUpsideDown(),
maxredirects: this.maxredirects,
accepted_statuscodes: this.getAcceptedStatuscodes(),
2021-08-22 22:05:48 +00:00
dns_resolve_type: this.dns_resolve_type,
dns_resolve_server: this.dns_resolve_server,
2021-07-30 11:18:26 +00:00
notificationIDList,
2021-06-25 13:55:49 +00:00
};
}
/**
* Parse to boolean
* @returns {boolean}
*/
getIgnoreTls() {
return Boolean(this.ignoreTls)
}
/**
* Parse to boolean
* @returns {boolean}
*/
isUpsideDown() {
return Boolean(this.upsideDown);
}
getAcceptedStatuscodes() {
return JSON.parse(this.accepted_statuscodes_json);
}
2021-06-25 13:55:49 +00:00
start(io) {
2021-06-29 08:06:20 +00:00
let previousBeat = null;
let retries = 0;
2021-06-29 08:06:20 +00:00
2021-07-27 16:52:31 +00:00
let prometheus = new Prometheus(this);
2021-06-27 08:10:55 +00:00
const beat = async () => {
2021-08-10 09:51:30 +00:00
// Expose here for prometheus update
// undefined if not https
let tlsInfo = undefined;
2021-06-29 08:06:20 +00:00
if (! previousBeat) {
previousBeat = await R.findOne("heartbeat", " monitor_id = ? ORDER BY time DESC", [
2021-07-30 11:18:26 +00:00
this.id,
2021-06-29 08:06:20 +00:00
])
}
const isFirstBeat = !previousBeat;
2021-06-27 08:10:55 +00:00
let bean = R.dispense("heartbeat")
bean.monitor_id = this.id;
bean.time = R.isoDateTime(dayjs.utc());
bean.status = DOWN;
2021-06-27 08:10:55 +00:00
if (this.isUpsideDown()) {
bean.status = flipStatus(bean.status);
}
// Duration
if (! isFirstBeat) {
2021-07-30 11:18:26 +00:00
bean.duration = dayjs(bean.time).diff(dayjs(previousBeat.time), "second");
} else {
bean.duration = 0;
}
2021-06-27 08:10:55 +00:00
try {
2021-07-01 09:19:28 +00:00
if (this.type === "http" || this.type === "keyword") {
// Do not do any queries/high loading things before the "bean.ping"
2021-06-27 08:10:55 +00:00
let startTime = dayjs().valueOf();
let res = await axios.get(this.url, {
2021-08-11 15:12:38 +00:00
timeout: this.interval * 1000 * 0.8,
2021-07-30 11:18:26 +00:00
headers: {
"Accept": "*/*",
2021-08-11 17:31:07 +00:00
"User-Agent": "Uptime-Kuma/" + version,
2021-07-30 11:18:26 +00:00
},
httpsAgent: new https.Agent({
maxCachedSessions: 0, // Use Custom agent to disable session reuse (https://github.com/nodejs/node/issues/3940)
rejectUnauthorized: ! this.getIgnoreTls(),
}),
maxRedirects: this.maxredirects,
validateStatus: (status) => {
return checkStatusCode(status, this.getAcceptedStatuscodes());
},
});
2021-06-27 08:10:55 +00:00
bean.msg = `${res.status} - ${res.statusText}`
bean.ping = dayjs().valueOf() - startTime;
2021-07-01 09:19:28 +00:00
// Check certificate if https is used
let certInfoStartTime = dayjs().valueOf();
2021-07-22 08:13:58 +00:00
if (this.getUrl()?.protocol === "https:") {
try {
2021-08-10 09:51:30 +00:00
tlsInfo = await this.updateTlsInfo(checkCertificate(res));
} catch (e) {
if (e.message !== "No TLS certificate in response") {
console.error(e.message)
}
}
}
2021-07-01 09:19:28 +00:00
debug("Cert Info Query Time: " + (dayjs().valueOf() - certInfoStartTime) + "ms")
2021-07-01 09:19:28 +00:00
if (this.type === "http") {
bean.status = UP;
2021-07-01 09:19:28 +00:00
} else {
2021-07-12 02:52:41 +00:00
let data = res.data;
// Convert to string for object/array
if (typeof data !== "string") {
data = JSON.stringify(data)
}
if (data.includes(this.keyword)) {
2021-07-01 09:19:28 +00:00
bean.msg += ", keyword is found"
bean.status = UP;
2021-07-01 09:19:28 +00:00
} else {
throw new Error(bean.msg + ", but keyword is not found")
}
}
2021-07-01 06:03:06 +00:00
} else if (this.type === "port") {
bean.ping = await tcping(this.hostname, this.port);
2021-07-01 13:47:14 +00:00
bean.msg = ""
bean.status = UP;
2021-07-01 09:00:23 +00:00
} else if (this.type === "ping") {
bean.ping = await ping(this.hostname);
2021-07-01 13:47:14 +00:00
bean.msg = ""
bean.status = UP;
2021-08-22 22:05:48 +00:00
} else if (this.type === "dns") {
let startTime = dayjs().valueOf();
let dnsMessage = "";
2021-08-22 22:05:48 +00:00
let dnsRes = await dnsResolve(this.hostname, this.dns_resolve_server, this.dns_resolve_type);
bean.ping = dayjs().valueOf() - startTime;
2021-08-22 22:05:48 +00:00
2021-08-25 07:31:42 +00:00
if (this.dns_resolve_type == "A" || this.dns_resolve_type == "AAAA" || this.dns_resolve_type == "TXT") {
dnsMessage += "Records: ";
2021-08-25 07:31:42 +00:00
dnsMessage += dnsRes.join(" | ");
} else if (this.dns_resolve_type == "CNAME" || this.dns_resolve_type == "PTR") {
dnsMessage = dnsRes[0];
2021-08-23 14:30:11 +00:00
} else if (this.dns_resolve_type == "CAA") {
dnsMessage = dnsRes[0].issue;
2021-08-23 14:30:11 +00:00
} else if (this.dns_resolve_type == "MX") {
2021-08-22 22:05:48 +00:00
dnsRes.forEach(record => {
dnsMessage += `Hostname: ${record.exchange} - Priority: ${record.priority} | `;
2021-08-22 22:05:48 +00:00
});
dnsMessage = dnsMessage.slice(0, -2)
2021-08-23 14:30:11 +00:00
} else if (this.dns_resolve_type == "NS") {
dnsMessage += "Servers: ";
2021-08-25 07:31:42 +00:00
dnsMessage += dnsRes.join(" | ");
2021-08-23 14:30:11 +00:00
} else if (this.dns_resolve_type == "SOA") {
2021-08-22 22:05:48 +00:00
dnsMessage += `NS-Name: ${dnsRes.nsname} | Hostmaster: ${dnsRes.hostmaster} | Serial: ${dnsRes.serial} | Refresh: ${dnsRes.refresh} | Retry: ${dnsRes.retry} | Expire: ${dnsRes.expire} | MinTTL: ${dnsRes.minttl}`;
2021-08-23 14:30:11 +00:00
} else if (this.dns_resolve_type == "SRV") {
2021-08-22 22:05:48 +00:00
dnsRes.forEach(record => {
dnsMessage += `Name: ${record.name} | Port: ${record.port} | Priority: ${record.priority} | Weight: ${record.weight} | `;
});
dnsMessage = dnsMessage.slice(0, -2)
2021-08-22 22:05:48 +00:00
}
bean.msg = dnsMessage;
bean.status = UP;
2021-06-27 08:10:55 +00:00
}
if (this.isUpsideDown()) {
bean.status = flipStatus(bean.status);
if (bean.status === DOWN) {
throw new Error("Flip UP to DOWN");
}
}
retries = 0;
2021-06-27 08:10:55 +00:00
} catch (error) {
bean.msg = error.message;
// If UP come in here, it must be upside down mode
// Just reset the retries
if (this.isUpsideDown() && bean.status === UP) {
retries = 0;
} else if ((this.maxretries > 0) && (retries < this.maxretries)) {
retries++;
bean.status = PENDING;
}
2021-06-27 08:10:55 +00:00
}
// * ? -> ANY STATUS = important [isFirstBeat]
// UP -> PENDING = not important
// * UP -> DOWN = important
// UP -> UP = not important
// PENDING -> PENDING = not important
// * PENDING -> DOWN = important
// PENDING -> UP = not important
// DOWN -> PENDING = this case not exists
// DOWN -> DOWN = not important
// * DOWN -> UP = important
let isImportant = isFirstBeat ||
(previousBeat.status === UP && bean.status === DOWN) ||
(previousBeat.status === DOWN && bean.status === UP) ||
(previousBeat.status === PENDING && bean.status === DOWN);
// Mark as important if status changed, ignore pending pings,
// Don't notify if disrupted changes to up
if (isImportant) {
2021-06-29 08:06:20 +00:00
bean.important = true;
// Send only if the first beat is DOWN
if (!isFirstBeat || bean.status === DOWN) {
2021-07-30 11:18:26 +00:00
let notificationList = await R.getAll("SELECT notification.* FROM notification, monitor_notification WHERE monitor_id = ? AND monitor_notification.notification_id = notification.id ", [
this.id,
])
let text;
if (bean.status === UP) {
text = "✅ Up"
} else {
text = "🔴 Down"
}
let msg = `[${this.name}] [${text}] ${bean.msg}`;
2021-07-30 11:18:26 +00:00
for (let notification of notificationList) {
try {
await Notification.send(JSON.parse(notification.config), msg, await this.toJSON(), bean.toJSON())
} catch (e) {
2021-08-23 12:57:42 +00:00
console.error("Cannot send notification to " + notification.name);
console.log(e);
}
}
}
2021-06-29 08:06:20 +00:00
} else {
bean.important = false;
}
if (bean.status === UP) {
2021-07-20 22:41:38 +00:00
console.info(`Monitor #${this.id} '${this.name}': Successful Response: ${bean.ping} ms | Interval: ${this.interval} seconds | Type: ${this.type}`)
} else if (bean.status === PENDING) {
2021-07-27 17:53:59 +00:00
console.warn(`Monitor #${this.id} '${this.name}': Pending: ${bean.msg} | Max retries: ${this.maxretries} | Type: ${this.type}`)
2021-07-20 22:41:38 +00:00
} else {
console.warn(`Monitor #${this.id} '${this.name}': Failing: ${bean.msg} | Type: ${this.type}`)
}
2021-06-29 08:06:20 +00:00
io.to(this.user_id).emit("heartbeat", bean.toJSON());
2021-07-01 06:03:06 +00:00
Monitor.sendStats(io, this.id, this.user_id)
2021-06-29 08:06:20 +00:00
await R.store(bean);
prometheus.update(bean, tlsInfo);
2021-06-29 08:06:20 +00:00
previousBeat = bean;
this.heartbeatInterval = setTimeout(beat, this.interval * 1000);
2021-06-25 13:55:49 +00:00
}
beat();
}
stop() {
clearTimeout(this.heartbeatInterval);
2021-06-25 13:55:49 +00:00
}
2021-06-30 13:04:58 +00:00
/**
* Helper Method:
* returns URL object for further usage
* returns null if url is invalid
* @returns {null|URL}
*/
getUrl() {
try {
return new URL(this.url);
} catch (_) {
return null;
}
}
/**
* Store TLS info to database
* @param checkCertificateResult
2021-08-10 09:51:30 +00:00
* @returns {Promise<object>}
*/
async updateTlsInfo(checkCertificateResult) {
let tls_info_bean = await R.findOne("monitor_tls_info", "monitor_id = ?", [
2021-07-30 11:18:26 +00:00
this.id,
]);
if (tls_info_bean == null) {
tls_info_bean = R.dispense("monitor_tls_info");
tls_info_bean.monitor_id = this.id;
}
tls_info_bean.info_json = JSON.stringify(checkCertificateResult);
await R.store(tls_info_bean);
2021-08-10 09:51:30 +00:00
return checkCertificateResult;
}
2021-06-30 13:04:58 +00:00
static async sendStats(io, monitorID, userID) {
2021-08-16 18:09:40 +00:00
await Monitor.sendAvgPing(24, io, monitorID, userID);
await Monitor.sendUptime(24, io, monitorID, userID);
await Monitor.sendUptime(24 * 30, io, monitorID, userID);
await Monitor.sendCertInfo(io, monitorID, userID);
2021-06-30 13:04:58 +00:00
}
2021-07-01 05:11:16 +00:00
/**
*
* @param duration : int Hours
*/
2021-06-30 13:04:58 +00:00
static async sendAvgPing(duration, io, monitorID, userID) {
2021-08-16 18:09:40 +00:00
const timeLogger = new TimeLogger();
2021-06-30 13:04:58 +00:00
let avgPing = parseInt(await R.getCell(`
SELECT AVG(ping)
FROM heartbeat
2021-07-10 04:04:40 +00:00
WHERE time > DATETIME('now', ? || ' hours')
2021-07-01 05:11:16 +00:00
AND ping IS NOT NULL
2021-06-30 13:04:58 +00:00
AND monitor_id = ? `, [
-duration,
2021-07-30 11:18:26 +00:00
monitorID,
2021-06-30 13:04:58 +00:00
]));
2021-08-16 18:09:40 +00:00
timeLogger.print(`[Monitor: ${monitorID}] avgPing`);
2021-06-30 13:04:58 +00:00
io.to(userID).emit("avgPing", monitorID, avgPing);
}
static async sendCertInfo(io, monitorID, userID) {
2021-07-30 11:18:26 +00:00
let tls_info = await R.findOne("monitor_tls_info", "monitor_id = ?", [
monitorID,
]);
if (tls_info != null) {
io.to(userID).emit("certInfo", monitorID, tls_info.info_json);
}
}
2021-07-01 05:11:16 +00:00
/**
2021-07-09 06:14:03 +00:00
* Uptime with calculation
* Calculation based on:
* https://www.uptrends.com/support/kb/reporting/calculation-of-uptime-and-downtime
2021-07-01 05:11:16 +00:00
* @param duration : int Hours
*/
static async sendUptime(duration, io, monitorID, userID) {
2021-08-16 18:09:40 +00:00
const timeLogger = new TimeLogger();
2021-07-01 09:00:23 +00:00
let sec = duration * 3600;
2021-07-11 12:07:03 +00:00
let heartbeatList = await R.getAll(`
2021-07-09 06:14:03 +00:00
SELECT duration, time, status
2021-07-01 05:11:16 +00:00
FROM heartbeat
2021-07-10 04:04:40 +00:00
WHERE time > DATETIME('now', ? || ' hours')
2021-07-01 05:11:16 +00:00
AND monitor_id = ? `, [
-duration,
2021-07-30 11:18:26 +00:00
monitorID,
2021-07-01 09:00:23 +00:00
]);
2021-08-16 18:09:40 +00:00
timeLogger.print(`[Monitor: ${monitorID}][${duration}] sendUptime`);
2021-07-01 09:00:23 +00:00
let downtime = 0;
2021-07-09 06:14:03 +00:00
let total = 0;
let uptime;
2021-07-01 09:00:23 +00:00
2021-07-11 12:07:03 +00:00
// Special handle for the first heartbeat only
if (heartbeatList.length === 1) {
2021-07-01 13:47:14 +00:00
2021-07-11 12:07:03 +00:00
if (heartbeatList[0].status === 1) {
uptime = 1;
} else {
uptime = 0;
}
} else {
for (let row of heartbeatList) {
let value = parseInt(row.duration)
let time = row.time
2021-07-01 09:00:23 +00:00
2021-07-11 12:07:03 +00:00
// Handle if heartbeat duration longer than the target duration
// e.g. Heartbeat duration = 28hrs, but target duration = 24hrs
if (value > sec) {
2021-07-30 11:18:26 +00:00
let trim = dayjs.utc().diff(dayjs(time), "second");
2021-07-11 12:07:03 +00:00
value = sec - trim;
if (value < 0) {
value = 0;
}
}
total += value;
if (row.status === 0 || row.status === 2) {
2021-07-11 12:07:03 +00:00
downtime += value;
2021-07-01 09:00:23 +00:00
}
}
2021-07-01 05:11:16 +00:00
2021-07-11 12:07:03 +00:00
uptime = (total - downtime) / total;
if (uptime < 0) {
uptime = 0;
2021-07-06 05:44:33 +00:00
}
2021-07-01 09:00:23 +00:00
}
2021-07-01 05:11:16 +00:00
io.to(userID).emit("uptime", monitorID, duration, uptime);
2021-06-30 13:04:58 +00:00
}
2021-06-25 13:55:49 +00:00
}
module.exports = Monitor;