2021-07-30 12:18:26 +01:00
const https = require ( "https" ) ;
2021-06-25 14:55:49 +01:00
const dayjs = require ( "dayjs" ) ;
2021-09-17 07:42:19 +01:00
const utc = require ( "dayjs/plugin/utc" ) ;
let timezone = require ( "dayjs/plugin/timezone" ) ;
dayjs . extend ( utc ) ;
dayjs . extend ( timezone ) ;
2021-06-27 09:10:55 +01:00
const axios = require ( "axios" ) ;
2021-07-30 12:18:26 +01:00
const { Prometheus } = require ( "../prometheus" ) ;
2021-09-08 12:54:37 +01:00
const { debug , UP , DOWN , PENDING , flipStatus , TimeLogger } = require ( "../../src/util" ) ;
2021-08-30 07:55:33 +01:00
const { tcping , ping , dnsResolve , checkCertificate , checkStatusCode , getTotalClientInRoom } = require ( "../util-server" ) ;
2021-07-30 12:18:26 +01:00
const { R } = require ( "redbean-node" ) ;
const { BeanModel } = require ( "redbean-node/dist/bean-model" ) ;
2021-09-17 07:42:19 +01:00
const { Notification } = require ( "../notification" ) ;
2021-08-12 17:13:46 +01:00
const version = require ( "../../package.json" ) . version ;
2021-06-27 09:10:55 +01:00
/ * *
* status :
* 0 = DOWN
* 1 = UP
2021-07-27 18:53:59 +01:00
* 2 = PENDING
2021-06-27 09:10:55 +01:00
* /
2021-06-25 14:55:49 +01:00
class Monitor extends BeanModel {
2021-09-12 19:26:45 +01:00
/ * *
* Return a object that ready to parse to JSON for public
* Only show necessary data to public
* /
async toPublicJSON ( ) {
2021-09-19 12:04:51 +01:00
return {
id : this . id ,
name : this . name ,
} ;
2021-09-12 19:26:45 +01:00
}
/ * *
* Return a object that ready to parse to JSON
* /
2021-07-09 10:55:48 +01:00
async toJSON ( ) {
let notificationIDList = { } ;
let list = await R . find ( "monitor_notification" , " monitor_id = ? " , [
2021-07-30 12:18:26 +01:00
this . id ,
2021-09-17 07:42:19 +01:00
] ) ;
2021-07-09 10:55:48 +01:00
for ( let bean of list ) {
notificationIDList [ bean . notification _id ] = true ;
}
2021-08-26 11:55:19 +01:00
const tags = 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 ] ) ;
2021-06-25 14:55:49 +01:00
return {
id : this . id ,
name : this . name ,
url : this . url ,
2021-07-01 07:03:06 +01:00
hostname : this . hostname ,
port : this . port ,
2021-07-19 17:23:06 +01:00
maxretries : this . maxretries ,
2021-07-01 06:11:16 +01:00
weight : this . weight ,
2021-06-25 14:55:49 +01:00
active : this . active ,
type : this . type ,
interval : this . interval ,
2021-09-11 17:54:55 +01:00
retryInterval : this . retryInterval ,
2021-07-01 10:19:28 +01:00
keyword : this . keyword ,
2021-07-30 15:11:14 +01:00
ignoreTls : this . getIgnoreTls ( ) ,
2021-07-30 17:01:04 +01:00
upsideDown : this . isUpsideDown ( ) ,
2021-08-05 12:04:38 +01:00
maxredirects : this . maxredirects ,
accepted _statuscodes : this . getAcceptedStatuscodes ( ) ,
2021-08-22 23:05:48 +01:00
dns _resolve _type : this . dns _resolve _type ,
dns _resolve _server : this . dns _resolve _server ,
2021-08-28 20:20:25 +01:00
dns _last _result : this . dns _last _result ,
2021-07-30 12:18:26 +01:00
notificationIDList ,
2021-08-26 11:55:19 +01:00
tags : tags ,
2021-06-25 14:55:49 +01:00
} ;
}
2021-07-30 15:11:14 +01:00
/ * *
* Parse to boolean
* @ returns { boolean }
* /
getIgnoreTls ( ) {
2021-09-17 07:42:19 +01:00
return Boolean ( this . ignoreTls ) ;
2021-07-30 15:11:14 +01:00
}
/ * *
* Parse to boolean
* @ returns { boolean }
* /
2021-07-30 17:01:04 +01:00
isUpsideDown ( ) {
2021-07-30 15:11:14 +01:00
return Boolean ( this . upsideDown ) ;
}
2021-08-05 12:04:38 +01:00
getAcceptedStatuscodes ( ) {
return JSON . parse ( this . accepted _statuscodes _json ) ;
}
2021-06-25 14:55:49 +01:00
start ( io ) {
2021-06-29 09:06:20 +01:00
let previousBeat = null ;
2021-07-19 17:23:06 +01:00
let retries = 0 ;
2021-06-29 09:06:20 +01:00
2021-07-27 17:52:31 +01:00
let prometheus = new Prometheus ( this ) ;
2021-07-22 16:00:11 +01:00
2021-06-27 09:10:55 +01:00
const beat = async ( ) => {
2021-09-08 12:54:37 +01:00
2021-08-10 10:51:30 +01:00
// Expose here for prometheus update
// undefined if not https
let tlsInfo = undefined ;
2021-06-29 09:06:20 +01:00
if ( ! previousBeat ) {
previousBeat = await R . findOne ( "heartbeat" , " monitor_id = ? ORDER BY time DESC" , [
2021-07-30 12:18:26 +01:00
this . id ,
2021-09-17 07:42:19 +01:00
] ) ;
2021-06-29 09:06:20 +01:00
}
2021-07-24 04:42:14 +01:00
const isFirstBeat = ! previousBeat ;
2021-09-17 07:42:19 +01:00
let bean = R . dispense ( "heartbeat" ) ;
2021-06-27 09:10:55 +01:00
bean . monitor _id = this . id ;
bean . time = R . isoDateTime ( dayjs . utc ( ) ) ;
2021-07-24 04:42:14 +01:00
bean . status = DOWN ;
2021-06-27 09:10:55 +01:00
2021-07-30 17:01:04 +01:00
if ( this . isUpsideDown ( ) ) {
bean . status = flipStatus ( bean . status ) ;
}
2021-06-30 19:02:54 +01:00
// Duration
2021-07-24 04:42:14 +01:00
if ( ! isFirstBeat ) {
2021-07-30 12:18:26 +01:00
bean . duration = dayjs ( bean . time ) . diff ( dayjs ( previousBeat . time ) , "second" ) ;
2021-06-30 19:02:54 +01:00
} else {
bean . duration = 0 ;
}
2021-06-27 09:10:55 +01:00
try {
2021-07-01 10:19:28 +01:00
if ( this . type === "http" || this . type === "keyword" ) {
2021-08-23 11:52:24 +01:00
// Do not do any queries/high loading things before the "bean.ping"
2021-06-27 09:10:55 +01:00
let startTime = dayjs ( ) . valueOf ( ) ;
2021-07-30 15:11:14 +01:00
2021-07-11 21:01:34 +01:00
let res = await axios . get ( this . url , {
2021-08-11 16:12:38 +01:00
timeout : this . interval * 1000 * 0.8 ,
2021-07-30 12:18:26 +01:00
headers : {
2021-08-10 13:23:15 +01:00
"Accept" : "*/*" ,
2021-08-11 18:31:07 +01:00
"User-Agent" : "Uptime-Kuma/" + version ,
2021-07-30 12:18:26 +01:00
} ,
2021-07-30 15:11:14 +01:00
httpsAgent : new https . Agent ( {
2021-08-23 11:52:24 +01:00
maxCachedSessions : 0 , // Use Custom agent to disable session reuse (https://github.com/nodejs/node/issues/3940)
2021-07-30 15:11:14 +01:00
rejectUnauthorized : ! this . getIgnoreTls ( ) ,
} ) ,
2021-08-05 12:04:38 +01:00
maxRedirects : this . maxredirects ,
validateStatus : ( status ) => {
return checkStatusCode ( status , this . getAcceptedStatuscodes ( ) ) ;
} ,
2021-07-23 04:22:37 +01:00
} ) ;
2021-09-17 07:42:19 +01:00
bean . msg = ` ${ res . status } - ${ res . statusText } ` ;
2021-06-27 09:10:55 +01:00
bean . ping = dayjs ( ) . valueOf ( ) - startTime ;
2021-07-01 10:19:28 +01:00
2021-07-22 09:04:32 +01:00
// Check certificate if https is used
2021-07-23 05:58:05 +01:00
let certInfoStartTime = dayjs ( ) . valueOf ( ) ;
2021-07-22 09:13:58 +01:00
if ( this . getUrl ( ) ? . protocol === "https:" ) {
2021-07-23 05:58:05 +01:00
try {
2021-08-10 10:51:30 +01:00
tlsInfo = await this . updateTlsInfo ( checkCertificate ( res ) ) ;
2021-07-23 05:58:05 +01:00
} catch ( e ) {
2021-08-08 06:47:29 +01:00
if ( e . message !== "No TLS certificate in response" ) {
2021-09-17 07:42:19 +01:00
console . error ( e . message ) ;
2021-08-08 06:47:29 +01:00
}
2021-07-23 05:58:05 +01:00
}
2021-07-21 05:09:09 +01:00
}
2021-07-01 10:19:28 +01:00
2021-09-17 07:42:19 +01:00
debug ( "Cert Info Query Time: " + ( dayjs ( ) . valueOf ( ) - certInfoStartTime ) + "ms" ) ;
2021-07-23 05:58:05 +01:00
2021-07-01 10:19:28 +01:00
if ( this . type === "http" ) {
2021-07-24 04:42:14 +01:00
bean . status = UP ;
2021-07-01 10:19:28 +01:00
} else {
2021-07-12 03:52:41 +01:00
let data = res . data ;
// Convert to string for object/array
if ( typeof data !== "string" ) {
2021-09-17 07:42:19 +01:00
data = JSON . stringify ( data ) ;
2021-07-12 03:52:41 +01:00
}
if ( data . includes ( this . keyword ) ) {
2021-09-17 07:42:19 +01:00
bean . msg += ", keyword is found" ;
2021-07-24 04:42:14 +01:00
bean . status = UP ;
2021-07-01 10:19:28 +01:00
} else {
2021-09-17 07:42:19 +01:00
throw new Error ( bean . msg + ", but keyword is not found" ) ;
2021-07-01 10:19:28 +01:00
}
}
2021-07-01 07:03:06 +01:00
} else if ( this . type === "port" ) {
bean . ping = await tcping ( this . hostname , this . port ) ;
2021-09-17 07:42:19 +01:00
bean . msg = "" ;
2021-07-24 04:42:14 +01:00
bean . status = UP ;
2021-07-01 10:00:23 +01:00
} else if ( this . type === "ping" ) {
bean . ping = await ping ( this . hostname ) ;
2021-09-17 07:42:19 +01:00
bean . msg = "" ;
2021-07-24 04:42:14 +01:00
bean . status = UP ;
2021-08-22 23:05:48 +01:00
} else if ( this . type === "dns" ) {
let startTime = dayjs ( ) . valueOf ( ) ;
2021-08-22 23:05:48 +01:00
let dnsMessage = "" ;
2021-08-22 23:05:48 +01:00
2021-08-22 23:05:48 +01:00
let dnsRes = await dnsResolve ( this . hostname , this . dns _resolve _server , this . dns _resolve _type ) ;
bean . ping = dayjs ( ) . valueOf ( ) - startTime ;
2021-08-22 23:05:48 +01:00
2021-08-25 08:31:42 +01:00
if ( this . dns _resolve _type == "A" || this . dns _resolve _type == "AAAA" || this . dns _resolve _type == "TXT" ) {
2021-08-24 10:47:12 +01:00
dnsMessage += "Records: " ;
2021-08-25 08:31:42 +01:00
dnsMessage += dnsRes . join ( " | " ) ;
2021-08-24 10:47:12 +01:00
} else if ( this . dns _resolve _type == "CNAME" || this . dns _resolve _type == "PTR" ) {
2021-08-22 23:05:48 +01:00
dnsMessage = dnsRes [ 0 ] ;
2021-08-23 15:30:11 +01:00
} else if ( this . dns _resolve _type == "CAA" ) {
2021-08-22 23:05:48 +01:00
dnsMessage = dnsRes [ 0 ] . issue ;
2021-08-23 15:30:11 +01:00
} else if ( this . dns _resolve _type == "MX" ) {
2021-08-22 23:05:48 +01:00
dnsRes . forEach ( record => {
2021-08-24 10:47:12 +01:00
dnsMessage += ` Hostname: ${ record . exchange } - Priority: ${ record . priority } | ` ;
2021-08-22 23:05:48 +01:00
} ) ;
2021-09-17 07:42:19 +01:00
dnsMessage = dnsMessage . slice ( 0 , - 2 ) ;
2021-08-23 15:30:11 +01:00
} else if ( this . dns _resolve _type == "NS" ) {
2021-08-24 10:47:12 +01:00
dnsMessage += "Servers: " ;
2021-08-25 08:31:42 +01:00
dnsMessage += dnsRes . join ( " | " ) ;
2021-08-23 15:30:11 +01:00
} else if ( this . dns _resolve _type == "SOA" ) {
2021-08-22 23:05:48 +01: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 15:30:11 +01:00
} else if ( this . dns _resolve _type == "SRV" ) {
2021-08-22 23:05:48 +01:00
dnsRes . forEach ( record => {
dnsMessage += ` Name: ${ record . name } | Port: ${ record . port } | Priority: ${ record . priority } | Weight: ${ record . weight } | ` ;
} ) ;
2021-09-17 07:42:19 +01:00
dnsMessage = dnsMessage . slice ( 0 , - 2 ) ;
2021-08-22 23:05:48 +01:00
}
2021-08-28 20:29:24 +01:00
if ( this . dnsLastResult !== dnsMessage ) {
2021-08-28 20:20:25 +01:00
R . exec ( "UPDATE `monitor` SET dns_last_result = ? WHERE id = ? " , [
dnsMessage ,
this . id
] ) ;
}
2021-08-22 23:05:48 +01:00
bean . msg = dnsMessage ;
bean . status = UP ;
2021-06-27 09:10:55 +01:00
}
2021-07-30 17:01:04 +01:00
if ( this . isUpsideDown ( ) ) {
bean . status = flipStatus ( bean . status ) ;
if ( bean . status === DOWN ) {
throw new Error ( "Flip UP to DOWN" ) ;
}
}
2021-07-19 17:23:06 +01:00
retries = 0 ;
2021-06-27 09:10:55 +01:00
} catch ( error ) {
2021-07-30 17:01:04 +01:00
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 ) ) {
2021-07-19 17:23:06 +01:00
retries ++ ;
2021-07-24 04:42:14 +01:00
bean . status = PENDING ;
2021-07-19 17:23:06 +01:00
}
2021-06-27 09:10:55 +01:00
}
2021-07-24 04:42:14 +01: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 ) ;
2021-07-20 10:50:33 +01:00
// Mark as important if status changed, ignore pending pings,
// Don't notify if disrupted changes to up
2021-07-24 04:42:14 +01:00
if ( isImportant ) {
2021-06-29 09:06:20 +01:00
bean . important = true ;
2021-07-09 10:55:48 +01:00
2021-07-24 04:42:14 +01:00
// Send only if the first beat is DOWN
if ( ! isFirstBeat || bean . status === DOWN ) {
2021-07-30 12:18:26 +01:00
let notificationList = await R . getAll ( "SELECT notification.* FROM notification, monitor_notification WHERE monitor_id = ? AND monitor_notification.notification_id = notification.id " , [
this . id ,
2021-09-17 07:42:19 +01:00
] ) ;
2021-07-09 10:55:48 +01:00
2021-07-09 18:15:21 +01:00
let text ;
2021-07-24 04:42:14 +01:00
if ( bean . status === UP ) {
2021-09-17 07:42:19 +01:00
text = "✅ Up" ;
2021-07-09 18:15:21 +01:00
} else {
2021-09-17 07:42:19 +01:00
text = "🔴 Down" ;
2021-07-09 18:15:21 +01:00
}
2021-07-09 10:55:48 +01:00
2021-07-09 18:15:21 +01:00
let msg = ` [ ${ this . name } ] [ ${ text } ] ${ bean . msg } ` ;
2021-07-09 10:55:48 +01:00
2021-07-30 12:18:26 +01:00
for ( let notification of notificationList ) {
2021-07-22 05:28:47 +01:00
try {
2021-09-17 07:42:19 +01:00
await Notification . send ( JSON . parse ( notification . config ) , msg , await this . toJSON ( ) , bean . toJSON ( ) ) ;
2021-07-22 05:28:47 +01:00
} catch ( e ) {
2021-08-23 13:57:42 +01:00
console . error ( "Cannot send notification to " + notification . name ) ;
console . log ( e ) ;
2021-07-22 05:28:47 +01:00
}
2021-07-09 18:15:21 +01:00
}
}
2021-07-09 10:55:48 +01:00
2021-06-29 09:06:20 +01:00
} else {
bean . important = false ;
}
2021-09-11 17:54:55 +01:00
let beatInterval = this . interval ;
2021-07-24 04:42:14 +01:00
if ( bean . status === UP ) {
2021-09-17 07:42:19 +01:00
console . info ( ` Monitor # ${ this . id } ' ${ this . name } ': Successful Response: ${ bean . ping } ms | Interval: ${ beatInterval } seconds | Type: ${ this . type } ` ) ;
2021-07-24 04:42:14 +01:00
} else if ( bean . status === PENDING ) {
2021-09-29 10:20:35 +01:00
if ( this . retryInterval > 0 ) {
2021-09-11 17:54:55 +01:00
beatInterval = this . retryInterval ;
}
2021-09-17 07:42:19 +01:00
console . warn ( ` Monitor # ${ this . id } ' ${ this . name } ': Pending: ${ bean . msg } | Max retries: ${ this . maxretries } | Retry: ${ retries } | Retry Interval: ${ beatInterval } seconds | Type: ${ this . type } ` ) ;
2021-07-20 23:41:38 +01:00
} else {
2021-09-17 07:42:19 +01:00
console . warn ( ` Monitor # ${ this . id } ' ${ this . name } ': Failing: ${ bean . msg } | Interval: ${ beatInterval } seconds | Type: ${ this . type } ` ) ;
2021-07-20 23:41:38 +01:00
}
2021-06-29 09:06:20 +01:00
io . to ( this . user _id ) . emit ( "heartbeat" , bean . toJSON ( ) ) ;
2021-09-17 07:42:19 +01:00
Monitor . sendStats ( io , this . id , this . user _id ) ;
2021-06-29 09:06:20 +01:00
2021-08-23 11:52:24 +01:00
await R . store ( bean ) ;
prometheus . update ( bean , tlsInfo ) ;
2021-06-29 09:06:20 +01:00
previousBeat = bean ;
2021-08-23 11:52:24 +01:00
2021-09-08 13:00:16 +01:00
if ( ! this . isStop ) {
2021-09-11 17:54:55 +01:00
this . heartbeatInterval = setTimeout ( beat , beatInterval * 1000 ) ;
2021-09-08 13:00:16 +01:00
}
2021-09-17 07:42:19 +01:00
} ;
2021-06-25 14:55:49 +01:00
beat ( ) ;
}
stop ( ) {
2021-08-23 11:52:24 +01:00
clearTimeout ( this . heartbeatInterval ) ;
2021-09-08 13:00:16 +01:00
this . isStop = true ;
2021-06-25 14:55:49 +01:00
}
2021-06-30 14:04:58 +01:00
2021-07-30 04:23:04 +01:00
/ * *
* Helper Method :
* returns URL object for further usage
* returns null if url is invalid
* @ returns { null | URL }
* /
2021-07-22 09:04:32 +01:00
getUrl ( ) {
try {
return new URL ( this . url ) ;
} catch ( _ ) {
return null ;
}
}
2021-07-30 04:23:04 +01:00
/ * *
* Store TLS info to database
* @ param checkCertificateResult
2021-08-10 10:51:30 +01:00
* @ returns { Promise < object > }
2021-07-30 04:23:04 +01:00
* /
2021-07-22 09:04:32 +01:00
async updateTlsInfo ( checkCertificateResult ) {
let tls _info _bean = await R . findOne ( "monitor_tls_info" , "monitor_id = ?" , [
2021-07-30 12:18:26 +01:00
this . id ,
2021-07-22 09:04:32 +01:00
] ) ;
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 ) ;
2021-07-23 05:58:05 +01:00
await R . store ( tls _info _bean ) ;
2021-08-10 10:51:30 +01:00
return checkCertificateResult ;
2021-07-22 09:04:32 +01:00
}
2021-06-30 14:04:58 +01:00
static async sendStats ( io , monitorID , userID ) {
2021-08-30 07:55:33 +01:00
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 {
debug ( "No clients in the room, no need to send stats" ) ;
}
2021-06-30 14:04:58 +01:00
}
2021-07-01 06:11:16 +01:00
/ * *
*
* @ param duration : int Hours
* /
2021-06-30 14:04:58 +01:00
static async sendAvgPing ( duration , io , monitorID , userID ) {
2021-08-16 19:09:40 +01:00
const timeLogger = new TimeLogger ( ) ;
2021-06-30 14:04:58 +01:00
let avgPing = parseInt ( await R . getCell ( `
SELECT AVG ( ping )
FROM heartbeat
2021-07-10 05:04:40 +01:00
WHERE time > DATETIME ( 'now' , ? || ' hours' )
2021-07-01 06:11:16 +01:00
AND ping IS NOT NULL
2021-06-30 14:04:58 +01:00
AND monitor _id = ? ` , [
- duration ,
2021-07-30 12:18:26 +01:00
monitorID ,
2021-06-30 14:04:58 +01:00
] ) ) ;
2021-08-16 19:09:40 +01:00
timeLogger . print ( ` [Monitor: ${ monitorID } ] avgPing ` ) ;
2021-06-30 14:04:58 +01:00
io . to ( userID ) . emit ( "avgPing" , monitorID , avgPing ) ;
}
2021-07-22 09:04:32 +01:00
static async sendCertInfo ( io , monitorID , userID ) {
2021-07-30 12:18:26 +01:00
let tls _info = await R . findOne ( "monitor_tls_info" , "monitor_id = ?" , [
monitorID ,
2021-07-22 09:04:32 +01:00
] ) ;
if ( tls _info != null ) {
io . to ( userID ) . emit ( "certInfo" , monitorID , tls _info . info _json ) ;
}
2021-07-21 05:09:09 +01:00
}
2021-07-01 06:11:16 +01:00
/ * *
2021-07-09 07:14:03 +01:00
* Uptime with calculation
* Calculation based on :
* https : //www.uptrends.com/support/kb/reporting/calculation-of-uptime-and-downtime
2021-07-01 06:11:16 +01:00
* @ param duration : int Hours
* /
2021-09-22 08:10:08 +01:00
static async calcUptime ( duration , monitorID ) {
2021-08-16 19:09:40 +01:00
const timeLogger = new TimeLogger ( ) ;
2021-09-09 08:46:28 +01: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 06:11:16 +01:00
FROM heartbeat
2021-09-09 08:46:28 +01:00
WHERE time > ?
AND monitor _id = ?
` , [
startTime , startTime , startTime , startTime , startTime ,
2021-07-30 12:18:26 +01:00
monitorID ,
2021-07-01 10:00:23 +01:00
] ) ;
2021-08-16 19:09:40 +01:00
timeLogger . print ( ` [Monitor: ${ monitorID } ][ ${ duration } ] sendUptime ` ) ;
2021-09-09 08:46:28 +01:00
let totalDuration = result . total _duration ;
let uptimeDuration = result . uptime _duration ;
2021-09-09 08:55:34 +01:00
let uptime = 0 ;
2021-07-01 06:11:16 +01:00
2021-09-09 08:55:34 +01:00
if ( totalDuration > 0 ) {
uptime = uptimeDuration / totalDuration ;
if ( uptime < 0 ) {
uptime = 0 ;
}
2021-07-11 13:07:03 +01:00
2021-09-09 08:55:34 +01: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 07:42:19 +01:00
2021-09-09 08:55:34 +01:00
if ( status === UP ) {
uptime = 1 ;
}
2021-07-01 10:00:23 +01:00
}
2021-09-22 08:10:08 +01:00
return uptime ;
}
/ * *
* Send Uptime
* @ param duration : int Hours
* /
static async sendUptime ( duration , io , monitorID , userID ) {
const uptime = await this . calcUptime ( duration , monitorID ) ;
2021-07-01 06:11:16 +01:00
io . to ( userID ) . emit ( "uptime" , monitorID , duration , uptime ) ;
2021-06-30 14:04:58 +01:00
}
2021-06-25 14:55:49 +01:00
}
module . exports = Monitor ;