1
0
mirror of https://github.com/louislam/uptime-kuma.git synced 2024-12-04 09:42:56 +02:00
uptime-kuma/server/model/monitor.js

916 lines
34 KiB
JavaScript
Raw Normal View History

2021-07-30 13:18:26 +02:00
const https = require("https");
2021-06-25 15:55:49 +02:00
const dayjs = require("dayjs");
2021-09-17 08:42:19 +02:00
const utc = require("dayjs/plugin/utc");
let timezone = require("dayjs/plugin/timezone");
dayjs.extend(utc);
dayjs.extend(timezone);
2021-06-27 10:10:55 +02:00
const axios = require("axios");
2021-07-30 13:18:26 +02:00
const { Prometheus } = require("../prometheus");
const { log, UP, DOWN, PENDING, flipStatus, TimeLogger } = require("../../src/util");
const { tcping, ping, dnsResolve, checkCertificate, checkStatusCode, getTotalClientInRoom, setting, mqttAsync } = require("../util-server");
2021-07-30 13:18:26 +02:00
const { R } = require("redbean-node");
const { BeanModel } = require("redbean-node/dist/bean-model");
2021-09-17 08:42:19 +02:00
const { Notification } = require("../notification");
const { Proxy } = require("../proxy");
2021-10-15 18:57:26 +02:00
const { demoMode } = require("../config");
2021-08-12 18:13:46 +02:00
const version = require("../../package.json").version;
const apicache = require("../modules/apicache");
const { UptimeKumaServer } = require("../uptime-kuma-server");
2021-06-27 10:10:55 +02:00
/**
* status:
* 0 = DOWN
* 1 = UP
2021-07-27 19:53:59 +02:00
* 2 = PENDING
2021-06-27 10:10:55 +02:00
*/
2021-06-25 15:55:49 +02:00
class Monitor extends BeanModel {
2021-09-12 20:26:45 +02:00
/**
2022-03-18 11:56:46 +02:00
* Return an object that ready to parse to JSON for public
2021-09-12 20:26:45 +02:00
* Only show necessary data to public
* @returns {Object}
2021-09-12 20:26:45 +02:00
*/
2022-03-18 11:56:46 +02:00
async toPublicJSON(showTags = false) {
let obj = {
id: this.id,
name: this.name,
};
2022-03-18 11:56:46 +02:00
if (showTags) {
obj.tags = await this.getTags();
}
return obj;
2021-09-12 20:26:45 +02:00
}
/**
2022-03-18 11:56:46 +02:00
* Return an object that ready to parse to JSON
* @returns {Object}
2021-09-12 20:26:45 +02:00
*/
2022-04-17 13:30:58 +02:00
async toJSON(includeSensitiveData = true) {
let notificationIDList = {};
let list = await R.find("monitor_notification", " monitor_id = ? ", [
2021-07-30 13:18:26 +02:00
this.id,
2021-09-17 08:42:19 +02:00
]);
for (let bean of list) {
notificationIDList[bean.notification_id] = true;
}
2022-03-18 11:56:46 +02:00
const tags = await this.getTags();
2022-04-17 13:30:58 +02:00
let data = {
2021-06-25 15:55:49 +02:00
id: this.id,
name: this.name,
url: this.url,
method: this.method,
2021-07-01 08:03:06 +02:00
hostname: this.hostname,
port: this.port,
maxretries: this.maxretries,
2021-07-01 07:11:16 +02:00
weight: this.weight,
2021-06-25 15:55:49 +02:00
active: this.active,
type: this.type,
interval: this.interval,
retryInterval: this.retryInterval,
2021-07-01 11:19:28 +02:00
keyword: this.keyword,
expiryNotification: this.isEnabledExpiryNotification(),
ignoreTls: this.getIgnoreTls(),
upsideDown: this.isUpsideDown(),
maxredirects: this.maxredirects,
accepted_statuscodes: this.getAcceptedStatuscodes(),
2021-08-23 00:05:48 +02:00
dns_resolve_type: this.dns_resolve_type,
dns_resolve_server: this.dns_resolve_server,
2021-08-28 21:20:25 +02:00
dns_last_result: this.dns_last_result,
proxyId: this.proxy_id,
2021-07-30 13:18:26 +02:00
notificationIDList,
tags: tags,
2021-12-18 23:35:18 +02:00
mqttUsername: this.mqttUsername,
mqttPassword: this.mqttPassword,
2021-12-18 23:35:18 +02:00
mqttTopic: this.mqttTopic,
mqttSuccessMessage: this.mqttSuccessMessage
2021-06-25 15:55:49 +02:00
};
2022-04-17 13:30:58 +02:00
if (includeSensitiveData) {
data = {
...data,
headers: this.headers,
body: this.body,
basic_auth_user: this.basic_auth_user,
basic_auth_pass: this.basic_auth_pass,
pushToken: this.pushToken,
};
}
return data;
2021-06-25 15:55:49 +02:00
}
/**
* Get all tags applied to this monitor
* @returns {Promise<LooseObject<any>[]>}
*/
2022-03-18 11:56:46 +02:00
async getTags() {
2022-04-17 09:27:35 +02:00
return await R.getAll("SELECT mt.*, tag.name, tag.color FROM monitor_tag mt JOIN tag ON mt.tag_id = tag.id WHERE mt.monitor_id = ?", [ this.id ]);
2022-03-18 11:56:46 +02:00
}
2021-11-02 13:30:44 +02:00
/**
* Encode user and password to Base64 encoding
* for HTTP "basic" auth, as per RFC-7617
* @returns {string}
*/
2021-11-23 06:59:48 +02:00
encodeBase64(user, pass) {
return Buffer.from(user + ":" + pass).toString("base64");
2021-11-02 14:11:33 +02:00
}
2021-11-02 13:30:44 +02:00
/**
* Is the TLS expiry notification enabled?
* @returns {boolean}
*/
isEnabledExpiryNotification() {
return Boolean(this.expiryNotification);
}
/**
* Parse to boolean
* @returns {boolean}
*/
getIgnoreTls() {
2021-09-17 08:42:19 +02:00
return Boolean(this.ignoreTls);
}
/**
* Parse to boolean
* @returns {boolean}
*/
isUpsideDown() {
return Boolean(this.upsideDown);
}
/**
* Get accepted status codes
* @returns {Object}
*/
getAcceptedStatuscodes() {
return JSON.parse(this.accepted_statuscodes_json);
}
/**
* Start monitor
* @param {Server} io Socket server instance
*/
2021-06-25 15:55:49 +02:00
start(io) {
2021-06-29 10:06:20 +02:00
let previousBeat = null;
let retries = 0;
2021-06-29 10:06:20 +02:00
2021-07-27 18:52:31 +02:00
let prometheus = new Prometheus(this);
2021-06-27 10:10:55 +02:00
const beat = async () => {
2022-02-24 09:11:17 +02:00
let beatInterval = this.interval;
if (! beatInterval) {
beatInterval = 1;
}
if (demoMode) {
if (beatInterval < 20) {
console.log("beat interval too low, reset to 20s");
beatInterval = 20;
}
}
2021-08-10 11:51:30 +02:00
// Expose here for prometheus update
// undefined if not https
let tlsInfo = undefined;
2022-05-09 21:10:12 +02:00
if (!previousBeat || this.type === "push") {
2021-06-29 10:06:20 +02:00
previousBeat = await R.findOne("heartbeat", " monitor_id = ? ORDER BY time DESC", [
2021-07-30 13:18:26 +02:00
this.id,
2021-09-17 08:42:19 +02:00
]);
2021-06-29 10:06:20 +02:00
}
const isFirstBeat = !previousBeat;
2021-09-17 08:42:19 +02:00
let bean = R.dispense("heartbeat");
2021-06-27 10:10:55 +02:00
bean.monitor_id = this.id;
bean.time = R.isoDateTimeMillis(dayjs.utc());
bean.status = DOWN;
2021-06-27 10:10:55 +02:00
if (this.isUpsideDown()) {
bean.status = flipStatus(bean.status);
}
// Duration
2021-11-04 03:46:43 +02:00
if (!isFirstBeat) {
2021-07-30 13:18:26 +02:00
bean.duration = dayjs(bean.time).diff(dayjs(previousBeat.time), "second");
} else {
bean.duration = 0;
}
2021-06-27 10:10:55 +02:00
try {
2021-07-01 11:19:28 +02:00
if (this.type === "http" || this.type === "keyword") {
// Do not do any queries/high loading things before the "bean.ping"
2021-06-27 10:10:55 +02:00
let startTime = dayjs().valueOf();
2021-11-02 13:30:44 +02:00
// HTTP basic auth
let basicAuthHeader = {};
if (this.basic_auth_user) {
basicAuthHeader = {
2021-11-23 06:59:48 +02:00
"Authorization": "Basic " + this.encodeBase64(this.basic_auth_user, this.basic_auth_pass),
2021-11-02 14:11:33 +02:00
};
2021-11-02 13:30:44 +02:00
}
const httpsAgentOptions = {
maxCachedSessions: 0, // Use Custom agent to disable session reuse (https://github.com/nodejs/node/issues/3940)
rejectUnauthorized: !this.getIgnoreTls(),
};
log.debug("monitor", `[${this.name}] Prepare Options for axios`);
const options = {
url: this.url,
method: (this.method || "get").toLowerCase(),
...(this.body ? { data: JSON.parse(this.body) } : {}),
2021-08-11 17:12:38 +02:00
timeout: this.interval * 1000 * 0.8,
2021-07-30 13:18:26 +02:00
headers: {
"Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9",
2021-08-11 19:31:07 +02:00
"User-Agent": "Uptime-Kuma/" + version,
2021-10-09 21:51:24 +02:00
...(this.headers ? JSON.parse(this.headers) : {}),
...(basicAuthHeader),
2021-07-30 13:18:26 +02:00
},
maxRedirects: this.maxredirects,
validateStatus: (status) => {
return checkStatusCode(status, this.getAcceptedStatuscodes());
},
};
2021-11-07 15:00:47 +02:00
if (this.proxy_id) {
const proxy = await R.load("proxy", this.proxy_id);
if (proxy && proxy.active) {
const { httpAgent, httpsAgent } = Proxy.createAgents(proxy, {
httpsAgentOptions: httpsAgentOptions,
});
options.proxy = false;
options.httpAgent = httpAgent;
options.httpsAgent = httpsAgent;
}
}
if (!options.httpsAgent) {
options.httpsAgent = new https.Agent(httpsAgentOptions);
}
log.debug("monitor", `[${this.name}] Axios Options: ${JSON.stringify(options)}`);
log.debug("monitor", `[${this.name}] Axios Request`);
let res = await axios.request(options);
2021-09-17 08:42:19 +02:00
bean.msg = `${res.status} - ${res.statusText}`;
2021-06-27 10:10:55 +02:00
bean.ping = dayjs().valueOf() - startTime;
2021-07-01 11:19:28 +02:00
// Check certificate if https is used
let certInfoStartTime = dayjs().valueOf();
2021-07-22 10:13:58 +02:00
if (this.getUrl()?.protocol === "https:") {
log.debug("monitor", `[${this.name}] Check cert`);
try {
let tlsInfoObject = checkCertificate(res);
tlsInfo = await this.updateTlsInfo(tlsInfoObject);
if (!this.getIgnoreTls() && this.isEnabledExpiryNotification()) {
log.debug("monitor", `[${this.name}] call sendCertNotification`);
await this.sendCertNotification(tlsInfoObject);
}
} catch (e) {
if (e.message !== "No TLS certificate in response") {
log.error("monitor", "Caught error");
log.error("monitor", e.message);
}
}
}
2021-07-01 11:19:28 +02:00
if (process.env.TIMELOGGER === "1") {
log.debug("monitor", "Cert Info Query Time: " + (dayjs().valueOf() - certInfoStartTime) + "ms");
}
2021-10-15 12:36:40 +02:00
2022-04-17 09:43:03 +02:00
if (process.env.UPTIME_KUMA_LOG_RESPONSE_BODY_MONITOR_ID === this.id) {
log.info("monitor", res.data);
2021-10-15 12:36:40 +02:00
}
2021-07-01 11:19:28 +02:00
if (this.type === "http") {
bean.status = UP;
2021-07-01 11:19:28 +02:00
} else {
2021-07-12 04:52:41 +02:00
let data = res.data;
// Convert to string for object/array
if (typeof data !== "string") {
2021-09-17 08:42:19 +02:00
data = JSON.stringify(data);
2021-07-12 04:52:41 +02:00
}
if (data.includes(this.keyword)) {
2021-09-17 08:42:19 +02:00
bean.msg += ", keyword is found";
bean.status = UP;
2021-07-01 11:19:28 +02:00
} else {
2021-09-17 08:42:19 +02:00
throw new Error(bean.msg + ", but keyword is not found");
2021-07-01 11:19:28 +02:00
}
}
2021-07-01 08:03:06 +02:00
} else if (this.type === "port") {
bean.ping = await tcping(this.hostname, this.port);
2021-09-17 08:42:19 +02:00
bean.msg = "";
bean.status = UP;
2021-07-01 11:00:23 +02:00
} else if (this.type === "ping") {
bean.ping = await ping(this.hostname);
2021-09-17 08:42:19 +02:00
bean.msg = "";
bean.status = UP;
2021-08-23 00:05:48 +02:00
} else if (this.type === "dns") {
let startTime = dayjs().valueOf();
let dnsMessage = "";
2021-08-23 00:05:48 +02:00
let dnsRes = await dnsResolve(this.hostname, this.dns_resolve_server, this.port, this.dns_resolve_type);
bean.ping = dayjs().valueOf() - startTime;
2021-08-23 00:05:48 +02:00
2022-04-17 09:43:03 +02:00
if (this.dns_resolve_type === "A" || this.dns_resolve_type === "AAAA" || this.dns_resolve_type === "TXT") {
dnsMessage += "Records: ";
2021-08-25 09:31:42 +02:00
dnsMessage += dnsRes.join(" | ");
2022-04-17 09:43:03 +02:00
} else if (this.dns_resolve_type === "CNAME" || this.dns_resolve_type === "PTR") {
dnsMessage = dnsRes[0];
2022-04-17 09:43:03 +02:00
} else if (this.dns_resolve_type === "CAA") {
dnsMessage = dnsRes[0].issue;
2022-04-17 09:43:03 +02:00
} else if (this.dns_resolve_type === "MX") {
2021-08-23 00:05:48 +02:00
dnsRes.forEach(record => {
dnsMessage += `Hostname: ${record.exchange} - Priority: ${record.priority} | `;
2021-08-23 00:05:48 +02:00
});
2021-09-17 08:42:19 +02:00
dnsMessage = dnsMessage.slice(0, -2);
2022-04-17 09:43:03 +02:00
} else if (this.dns_resolve_type === "NS") {
dnsMessage += "Servers: ";
2021-08-25 09:31:42 +02:00
dnsMessage += dnsRes.join(" | ");
2022-04-17 09:43:03 +02:00
} else if (this.dns_resolve_type === "SOA") {
2021-08-23 00:05:48 +02:00
dnsMessage += `NS-Name: ${dnsRes.nsname} | Hostmaster: ${dnsRes.hostmaster} | Serial: ${dnsRes.serial} | Refresh: ${dnsRes.refresh} | Retry: ${dnsRes.retry} | Expire: ${dnsRes.expire} | MinTTL: ${dnsRes.minttl}`;
2022-04-17 09:43:03 +02:00
} else if (this.dns_resolve_type === "SRV") {
2021-08-23 00:05:48 +02:00
dnsRes.forEach(record => {
dnsMessage += `Name: ${record.name} | Port: ${record.port} | Priority: ${record.priority} | Weight: ${record.weight} | `;
});
2021-09-17 08:42:19 +02:00
dnsMessage = dnsMessage.slice(0, -2);
2021-08-23 00:05:48 +02:00
}
2021-08-28 21:29:24 +02:00
if (this.dnsLastResult !== dnsMessage) {
2021-08-28 21:20:25 +02:00
R.exec("UPDATE `monitor` SET dns_last_result = ? WHERE id = ? ", [
dnsMessage,
this.id
]);
}
2021-08-23 00:05:48 +02:00
bean.msg = dnsMessage;
bean.status = UP;
2021-09-30 18:09:43 +02:00
} else if (this.type === "push") { // Type: Push
2022-05-27 06:45:56 +02:00
log.debug("monitor", `[${this.name}] Checking monitor at ${dayjs().format("YYYY-MM-DD HH:mm:ss.SSS")}`);
const bufferTime = 1000; // 1s buffer to accommodate clock differences
// If the previous beat was nonexistent, down or pending we use the regular
// beatInterval/retryInterval in the setTimeout further below
if (previousBeat) {
const msSinceLastBeat = dayjs.utc().valueOf() - dayjs.utc(previousBeat.time).valueOf();
2022-05-28 17:22:44 +02:00
log.debug("monitor", `[${this.name}] msSinceLastBeat = ${msSinceLastBeat}`);
if (previousBeat.status !== UP || msSinceLastBeat > beatInterval * 1000 + bufferTime) {
throw new Error("No heartbeat in the time window");
} else {
let timeout = beatInterval * 1000 - msSinceLastBeat;
if (timeout < 0) {
timeout = bufferTime;
} else {
timeout += bufferTime;
}
// No need to insert successful heartbeat for push type, so end here
retries = 0;
2022-05-27 06:45:56 +02:00
log.debug("monitor", `[${this.name}] timeout = ${timeout}`);
this.heartbeatInterval = setTimeout(beat, timeout);
return;
}
2021-09-30 18:09:43 +02:00
}
2021-09-27 11:17:57 +02:00
} else if (this.type === "steam") {
const steamApiUrl = "https://api.steampowered.com/IGameServersService/GetServerList/v1/";
const steamAPIKey = await setting("steamAPIKey");
2021-09-27 11:17:57 +02:00
const filter = `addr\\${this.hostname}:${this.port}`;
if (!steamAPIKey) {
throw new Error("Steam API Key not found");
}
2021-09-27 11:17:57 +02:00
let res = await axios.get(steamApiUrl, {
timeout: this.interval * 1000 * 0.8,
headers: {
"Accept": "*/*",
"User-Agent": "Uptime-Kuma/" + version,
},
httpsAgent: new https.Agent({
maxCachedSessions: 0, // Use Custom agent to disable session reuse (https://github.com/nodejs/node/issues/3940)
2021-11-04 03:46:43 +02:00
rejectUnauthorized: !this.getIgnoreTls(),
2021-09-27 11:17:57 +02:00
}),
maxRedirects: this.maxredirects,
validateStatus: (status) => {
return checkStatusCode(status, this.getAcceptedStatuscodes());
},
params: {
filter: filter,
key: steamAPIKey,
2021-09-27 11:17:57 +02:00
}
});
if (res.data.response && res.data.response.servers && res.data.response.servers.length > 0) {
bean.status = UP;
bean.msg = res.data.response.servers[0].name;
2021-09-27 11:17:57 +02:00
try {
bean.ping = await ping(this.hostname);
} catch (_) { }
2021-09-27 11:17:57 +02:00
} else {
throw new Error("Server not found on Steam");
2021-09-27 11:17:57 +02:00
}
2021-11-04 03:46:43 +02:00
} else if (this.type === "mqtt") {
bean.msg = await mqttAsync(this.hostname, this.mqttTopic, this.mqttSuccessMessage, {
port: this.port,
username: this.mqttUsername,
password: this.mqttPassword,
interval: this.interval,
});
bean.status = UP;
2021-09-30 18:09:43 +02:00
} else {
bean.msg = "Unknown Monitor Type";
bean.status = PENDING;
2021-06-27 10:10:55 +02: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 10:10:55 +02: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 10:10:55 +02:00
}
log.debug("monitor", `[${this.name}] Check isImportant`);
let isImportant = Monitor.isImportantBeat(isFirstBeat, previousBeat?.status, bean.status);
// Mark as important if status changed, ignore pending pings,
// Don't notify if disrupted changes to up
if (isImportant) {
2021-06-29 10:06:20 +02:00
bean.important = true;
2021-11-07 15:00:47 +02:00
log.debug("monitor", `[${this.name}] sendNotification`);
await Monitor.sendNotification(isFirstBeat, this, bean);
// Clear Status Page Cache
log.debug("monitor", `[${this.name}] apicache clear`);
apicache.clear();
2021-06-29 10:06:20 +02:00
} else {
bean.important = false;
}
if (bean.status === UP) {
log.info("monitor", `Monitor #${this.id} '${this.name}': Successful Response: ${bean.ping} ms | Interval: ${beatInterval} seconds | Type: ${this.type}`);
} else if (bean.status === PENDING) {
2021-09-29 11:20:35 +02:00
if (this.retryInterval > 0) {
beatInterval = this.retryInterval;
}
log.warn("monitor", `Monitor #${this.id} '${this.name}': Pending: ${bean.msg} | Max retries: ${this.maxretries} | Retry: ${retries} | Retry Interval: ${beatInterval} seconds | Type: ${this.type}`);
2021-07-21 00:41:38 +02:00
} else {
log.warn("monitor", `Monitor #${this.id} '${this.name}': Failing: ${bean.msg} | Interval: ${beatInterval} seconds | Type: ${this.type}`);
2021-07-21 00:41:38 +02:00
}
log.debug("monitor", `[${this.name}] Send to socket`);
2021-06-29 10:06:20 +02:00
io.to(this.user_id).emit("heartbeat", bean.toJSON());
2021-09-17 08:42:19 +02:00
Monitor.sendStats(io, this.id, this.user_id);
2021-06-29 10:06:20 +02:00
log.debug("monitor", `[${this.name}] Store`);
await R.store(bean);
2021-11-07 15:00:47 +02:00
log.debug("monitor", `[${this.name}] prometheus.update`);
prometheus.update(bean, tlsInfo);
2021-06-29 10:06:20 +02:00
previousBeat = bean;
2021-09-08 14:00:16 +02:00
if (! this.isStop) {
log.debug("monitor", `[${this.name}] SetTimeout for next check.`);
this.heartbeatInterval = setTimeout(safeBeat, beatInterval * 1000);
2021-11-07 15:00:47 +02:00
} else {
log.info("monitor", `[${this.name}] isStop = true, no next check.`);
2021-09-08 14:00:16 +02:00
}
2021-09-17 08:42:19 +02:00
};
2021-06-25 15:55:49 +02:00
/** Get a heartbeat and handle errors */
const safeBeat = async () => {
try {
await beat();
} catch (e) {
console.trace(e);
UptimeKumaServer.errorLog(e, false);
log.error("monitor", "Please report to https://github.com/louislam/uptime-kuma/issues");
if (! this.isStop) {
log.info("monitor", "Try to restart the monitor");
this.heartbeatInterval = setTimeout(safeBeat, this.interval * 1000);
}
}
};
2021-09-30 18:09:43 +02:00
// Delay Push Type
if (this.type === "push") {
setTimeout(() => {
safeBeat();
2021-09-30 18:09:43 +02:00
}, this.interval * 1000);
} else {
safeBeat();
2021-09-30 18:09:43 +02:00
}
2021-06-25 15:55:49 +02:00
}
/** Stop monitor */
2021-06-25 15:55:49 +02:00
stop() {
clearTimeout(this.heartbeatInterval);
2021-09-08 14:00:16 +02:00
this.isStop = true;
this.prometheus().remove();
2021-06-25 15:55:49 +02:00
}
2021-06-30 15:04:58 +02:00
/**
* Get a new prometheus instance
* @returns {Prometheus}
*/
prometheus() {
return new Prometheus(this);
2021-06-25 15:55:49 +02:00
}
2021-06-30 15:04:58 +02: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
* @returns {Promise<Object>}
*/
async updateTlsInfo(checkCertificateResult) {
2022-04-13 18:30:32 +02:00
let tlsInfoBean = await R.findOne("monitor_tls_info", "monitor_id = ?", [
2021-07-30 13:18:26 +02:00
this.id,
]);
2022-04-13 18:30:32 +02:00
if (tlsInfoBean == null) {
tlsInfoBean = R.dispense("monitor_tls_info");
tlsInfoBean.monitor_id = this.id;
} else {
// Clear sent history if the cert changed.
try {
2022-04-13 18:30:32 +02:00
let oldCertInfo = JSON.parse(tlsInfoBean.info_json);
let isValidObjects = oldCertInfo && oldCertInfo.certInfo && checkCertificateResult && checkCertificateResult.certInfo;
if (isValidObjects) {
if (oldCertInfo.certInfo.fingerprint256 !== checkCertificateResult.certInfo.fingerprint256) {
log.debug("monitor", "Resetting sent_history");
await R.exec("DELETE FROM notification_sent_history WHERE type = 'certificate' AND monitor_id = ?", [
this.id
]);
} else {
log.debug("monitor", "No need to reset sent_history");
log.debug("monitor", oldCertInfo.certInfo.fingerprint256);
log.debug("monitor", checkCertificateResult.certInfo.fingerprint256);
}
} else {
log.debug("monitor", "Not valid object");
}
} catch (e) { }
}
2022-04-13 18:30:32 +02:00
tlsInfoBean.info_json = JSON.stringify(checkCertificateResult);
await R.store(tlsInfoBean);
2021-08-10 11:51:30 +02:00
return checkCertificateResult;
}
/**
* Send statistics to clients
* @param {Server} io Socket server instance
* @param {number} monitorID ID of monitor to send
* @param {number} userID ID of user to send to
*/
2021-06-30 15:04:58 +02:00
static async sendStats(io, monitorID, userID) {
const hasClients = getTotalClientInRoom(io, userID) > 0;
if (hasClients) {
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);
} else {
log.debug("monitor", "No clients in the room, no need to send stats");
}
2021-06-30 15:04:58 +02:00
}
2021-07-01 07:11:16 +02:00
/**
* Send the average ping to user
* @param {number} duration Hours
2021-07-01 07:11:16 +02:00
*/
2021-06-30 15:04:58 +02:00
static async sendAvgPing(duration, io, monitorID, userID) {
2021-08-16 20:09:40 +02:00
const timeLogger = new TimeLogger();
2021-06-30 15:04:58 +02:00
let avgPing = parseInt(await R.getCell(`
SELECT AVG(ping)
FROM heartbeat
2021-07-10 06:04:40 +02:00
WHERE time > DATETIME('now', ? || ' hours')
2021-07-01 07:11:16 +02:00
AND ping IS NOT NULL
2021-06-30 15:04:58 +02:00
AND monitor_id = ? `, [
-duration,
2021-07-30 13:18:26 +02:00
monitorID,
2021-06-30 15:04:58 +02:00
]));
2021-08-16 20:09:40 +02:00
timeLogger.print(`[Monitor: ${monitorID}] avgPing`);
2021-06-30 15:04:58 +02:00
io.to(userID).emit("avgPing", monitorID, avgPing);
}
/**
* Send certificate information to client
* @param {Server} io Socket server instance
* @param {number} monitorID ID of monitor to send
* @param {number} userID ID of user to send to
*/
static async sendCertInfo(io, monitorID, userID) {
let tlsInfo = await R.findOne("monitor_tls_info", "monitor_id = ?", [
2021-07-30 13:18:26 +02:00
monitorID,
]);
if (tlsInfo != null) {
io.to(userID).emit("certInfo", monitorID, tlsInfo.info_json);
}
}
2021-07-01 07:11:16 +02:00
/**
2021-07-09 08:14:03 +02:00
* Uptime with calculation
* Calculation based on:
* https://www.uptrends.com/support/kb/reporting/calculation-of-uptime-and-downtime
* @param {number} duration Hours
* @param {number} monitorID ID of monitor to calculate
2021-07-01 07:11:16 +02:00
*/
2021-09-22 09:10:08 +02:00
static async calcUptime(duration, monitorID) {
2021-08-16 20:09:40 +02:00
const timeLogger = new TimeLogger();
2021-09-09 09:46:28 +02:00
const startTime = R.isoDateTime(dayjs.utc().subtract(duration, "hour"));
// Handle if heartbeat duration longer than the target duration
// e.g. If the last beat's duration is bigger that the 24hrs window, it will use the duration between the (beat time - window margin) (THEN case in SQL)
let result = await R.getRow(`
SELECT
-- SUM all duration, also trim off the beat out of time window
SUM(
CASE
WHEN (JULIANDAY(\`time\`) - JULIANDAY(?)) * 86400 < duration
THEN (JULIANDAY(\`time\`) - JULIANDAY(?)) * 86400
ELSE duration
END
) AS total_duration,
-- SUM all uptime duration, also trim off the beat out of time window
SUM(
CASE
WHEN (status = 1)
THEN
CASE
WHEN (JULIANDAY(\`time\`) - JULIANDAY(?)) * 86400 < duration
THEN (JULIANDAY(\`time\`) - JULIANDAY(?)) * 86400
ELSE duration
END
END
) AS uptime_duration
2021-07-01 07:11:16 +02:00
FROM heartbeat
2021-09-09 09:46:28 +02:00
WHERE time > ?
AND monitor_id = ?
`, [
startTime, startTime, startTime, startTime, startTime,
2021-07-30 13:18:26 +02:00
monitorID,
2021-07-01 11:00:23 +02:00
]);
2021-08-16 20:09:40 +02:00
timeLogger.print(`[Monitor: ${monitorID}][${duration}] sendUptime`);
2021-09-09 09:46:28 +02:00
let totalDuration = result.total_duration;
let uptimeDuration = result.uptime_duration;
let uptime = 0;
2021-07-01 07:11:16 +02:00
if (totalDuration > 0) {
uptime = uptimeDuration / totalDuration;
if (uptime < 0) {
uptime = 0;
}
2021-07-11 14:07:03 +02:00
} else {
// Handle new monitor with only one beat, because the beat's duration = 0
let status = parseInt(await R.getCell("SELECT `status` FROM heartbeat WHERE monitor_id = ?", [ monitorID ]));
2021-09-17 08:42:19 +02:00
if (status === UP) {
uptime = 1;
}
2021-07-01 11:00:23 +02:00
}
2021-09-22 09:10:08 +02:00
return uptime;
}
/**
* Send Uptime
* @param {number} duration Hours
* @param {Server} io Socket server instance
* @param {number} monitorID ID of monitor to send
* @param {number} userID ID of user to send to
2021-09-22 09:10:08 +02:00
*/
static async sendUptime(duration, io, monitorID, userID) {
const uptime = await this.calcUptime(duration, monitorID);
2021-07-01 07:11:16 +02:00
io.to(userID).emit("uptime", monitorID, duration, uptime);
2021-06-30 15:04:58 +02:00
}
/**
* Has status of monitor changed since last beat?
* @param {boolean} isFirstBeat Is this the first beat of this monitor?
* @param {const} previousBeatStatus Status of the previous beat
* @param {const} currentBeatStatus Status of the current beat
* @returns {boolean} True if is an important beat else false
*/
static isImportantBeat(isFirstBeat, previousBeatStatus, currentBeatStatus) {
// * ? -> 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 ||
(previousBeatStatus === UP && currentBeatStatus === DOWN) ||
(previousBeatStatus === DOWN && currentBeatStatus === UP) ||
(previousBeatStatus === PENDING && currentBeatStatus === DOWN);
return isImportant;
}
/**
* Send a notification about a monitor
* @param {boolean} isFirstBeat Is this beat the first of this monitor?
* @param {Monitor} monitor The monitor to send a notificaton about
* @param {Bean} bean Status information about monitor
*/
static async sendNotification(isFirstBeat, monitor, bean) {
if (!isFirstBeat || bean.status === DOWN) {
const notificationList = await Monitor.getNotificationList(monitor);
let text;
if (bean.status === UP) {
text = "✅ Up";
} else {
text = "🔴 Down";
}
let msg = `[${monitor.name}] [${text}] ${bean.msg}`;
for (let notification of notificationList) {
try {
2022-04-17 13:30:58 +02:00
await Notification.send(JSON.parse(notification.config), msg, await monitor.toJSON(false), bean.toJSON());
} catch (e) {
log.error("monitor", "Cannot send notification to " + notification.name);
log.error("monitor", e);
}
}
}
}
/**
* Get list of notification providers for a given monitor
* @param {Monitor} monitor Monitor to get notification providers for
* @returns {Promise<LooseObject<any>[]>}
*/
static async getNotificationList(monitor) {
let notificationList = await R.getAll("SELECT notification.* FROM notification, monitor_notification WHERE monitor_id = ? AND monitor_notification.notification_id = notification.id ", [
monitor.id,
]);
return notificationList;
}
/**
* Send notification about a certificate
* @param {Object} tlsInfoObject Information about certificate
*/
async sendCertNotification(tlsInfoObject) {
if (tlsInfoObject && tlsInfoObject.certInfo && tlsInfoObject.certInfo.daysRemaining) {
const notificationList = await Monitor.getNotificationList(this);
log.debug("monitor", "call sendCertNotificationByTargetDays");
await this.sendCertNotificationByTargetDays(tlsInfoObject.certInfo.daysRemaining, 21, notificationList);
await this.sendCertNotificationByTargetDays(tlsInfoObject.certInfo.daysRemaining, 14, notificationList);
await this.sendCertNotificationByTargetDays(tlsInfoObject.certInfo.daysRemaining, 7, notificationList);
}
}
/**
* Send a certificate notification when certificate expires in less
* than target days
* @param {number} daysRemaining Number of days remaining on certifcate
* @param {number} targetDays Number of days to alert after
* @param {LooseObject<any>[]} notificationList List of notification providers
* @returns {Promise<void>}
*/
async sendCertNotificationByTargetDays(daysRemaining, targetDays, notificationList) {
if (daysRemaining > targetDays) {
log.debug("monitor", `No need to send cert notification. ${daysRemaining} > ${targetDays}`);
return;
}
if (notificationList.length > 0) {
let row = await R.getRow("SELECT * FROM notification_sent_history WHERE type = ? AND monitor_id = ? AND days = ?", [
"certificate",
this.id,
targetDays,
]);
// Sent already, no need to send again
if (row) {
log.debug("monitor", "Sent already, no need to send again");
return;
}
let sent = false;
log.debug("monitor", "Send certificate notification");
for (let notification of notificationList) {
try {
log.debug("monitor", "Sending to " + notification.name);
await Notification.send(JSON.parse(notification.config), `[${this.name}][${this.url}] Certificate will be expired in ${daysRemaining} days`);
sent = true;
} catch (e) {
log.error("monitor", "Cannot send cert notification to " + notification.name);
log.error("monitor", e);
}
}
if (sent) {
await R.exec("INSERT INTO notification_sent_history (type, monitor_id, days) VALUES(?, ?, ?)", [
"certificate",
this.id,
targetDays,
]);
}
} else {
log.debug("monitor", "No notification, no need to send cert notification");
}
}
2021-12-08 08:59:59 +02:00
/**
* Get the status of the previous heartbeat
* @param {number} monitorID ID of monitor to check
* @returns {Promise<LooseObject<any>>}
*/
2021-12-08 08:59:59 +02:00
static async getPreviousHeartbeat(monitorID) {
return await R.getRow(`
SELECT status, time FROM heartbeat
WHERE id = (select MAX(id) from heartbeat where monitor_id = ?)
`, [
monitorID
]);
}
2021-06-25 15:55:49 +02:00
}
module.exports = Monitor;