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" ) ;
2021-09-08 13:54:37 +02:00
const { debug , UP , DOWN , PENDING , flipStatus , TimeLogger } = require ( "../../src/util" ) ;
2021-10-29 12:24:47 +02:00
const { tcping , ping , dnsResolve , checkCertificate , checkStatusCode , getTotalClientInRoom , setting , errorLog } = 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" ) ;
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 ;
2021-10-09 11:04:51 +02:00
const apicache = require ( "../modules/apicache" ) ;
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
/ * *
* Return a object that ready to parse to JSON for public
* Only show necessary data to public
* /
async toPublicJSON ( ) {
2021-09-19 13:04:51 +02:00
return {
id : this . id ,
name : this . name ,
} ;
2021-09-12 20:26:45 +02:00
}
/ * *
* Return a object that ready to parse to JSON
* /
2021-07-09 11:55:48 +02:00
async toJSON ( ) {
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
] ) ;
2021-07-09 11:55:48 +02:00
for ( let bean of list ) {
notificationIDList [ bean . notification _id ] = true ;
}
2021-08-26 12:55:19 +02: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 15:55:49 +02:00
return {
id : this . id ,
name : this . name ,
url : this . url ,
2021-10-02 16:48:27 +02:00
method : this . method ,
body : this . body ,
headers : this . headers ,
2021-11-02 13:30:44 +02:00
basicauth _user : this . basicauth _user ,
basicauth _pass : this . basicauth _pass ,
2021-07-01 08:03:06 +02:00
hostname : this . hostname ,
port : this . port ,
2021-07-19 18:23:06 +02:00
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 ,
2021-09-11 18:54:55 +02:00
retryInterval : this . retryInterval ,
2021-07-01 11:19:28 +02:00
keyword : this . keyword ,
2021-07-30 16:11:14 +02:00
ignoreTls : this . getIgnoreTls ( ) ,
2021-07-30 18:01:04 +02:00
upsideDown : this . isUpsideDown ( ) ,
2021-08-05 13:04:38 +02:00
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 ,
2021-09-30 18:09:43 +02:00
pushToken : this . pushToken ,
2021-07-30 13:18:26 +02:00
notificationIDList ,
2021-08-26 12:55:19 +02:00
tags : tags ,
2021-06-25 15:55:49 +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-02 14:11:33 +02:00
encodeB64 ( user , pass ) {
2021-11-02 13:30:44 +02:00
return btoa ( user + ":" + pass ) ;
2021-11-02 14:11:33 +02:00
}
2021-11-02 13:30:44 +02:00
2021-07-30 16:11:14 +02:00
/ * *
* Parse to boolean
* @ returns { boolean }
* /
getIgnoreTls ( ) {
2021-09-17 08:42:19 +02:00
return Boolean ( this . ignoreTls ) ;
2021-07-30 16:11:14 +02:00
}
/ * *
* Parse to boolean
* @ returns { boolean }
* /
2021-07-30 18:01:04 +02:00
isUpsideDown ( ) {
2021-07-30 16:11:14 +02:00
return Boolean ( this . upsideDown ) ;
}
2021-08-05 13:04:38 +02:00
getAcceptedStatuscodes ( ) {
return JSON . parse ( this . accepted _statuscodes _json ) ;
}
2021-06-25 15:55:49 +02:00
start ( io ) {
2021-06-29 10:06:20 +02:00
let previousBeat = null ;
2021-07-19 18:23:06 +02:00
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-07-22 17:00:11 +02:00
2021-06-27 10:10:55 +02:00
const beat = async ( ) => {
2021-09-08 13:54:37 +02:00
2021-08-10 11:51:30 +02:00
// Expose here for prometheus update
// undefined if not https
let tlsInfo = undefined ;
2021-06-29 10:06:20 +02:00
if ( ! previousBeat ) {
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
}
2021-07-24 05:42:14 +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 . isoDateTime ( dayjs . utc ( ) ) ;
2021-07-24 05:42:14 +02:00
bean . status = DOWN ;
2021-06-27 10:10:55 +02:00
2021-07-30 18:01:04 +02:00
if ( this . isUpsideDown ( ) ) {
bean . status = flipStatus ( bean . status ) ;
}
2021-06-30 20:02:54 +02:00
// Duration
2021-07-24 05:42:14 +02:00
if ( ! isFirstBeat ) {
2021-07-30 13:18:26 +02:00
bean . duration = dayjs ( bean . time ) . diff ( dayjs ( previousBeat . time ) , "second" ) ;
2021-06-30 20:02:54 +02:00
} 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" ) {
2021-08-23 12:52:24 +02:00
// 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-07-30 16:11:14 +02:00
2021-11-02 13:30:44 +02:00
// HTTP basic auth
let basicauthHeader = { } ;
if ( this . basicauth _user ) {
basicauthHeader = {
"Authorization" : "Basic " + this . encodeB64 ( this . basicauth _user , this . basicauth _pass )
2021-11-02 14:11:33 +02:00
} ;
2021-11-02 13:30:44 +02:00
}
2021-10-02 16:48:27 +02:00
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 : {
2021-08-10 14:23:15 +02:00
"Accept" : "*/*" ,
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 ) : { } ) ,
2021-11-02 13:30:44 +02:00
... ( basicauthHeader )
2021-07-30 13:18:26 +02:00
} ,
2021-07-30 16:11:14 +02:00
httpsAgent : new https . Agent ( {
2021-08-23 12:52:24 +02:00
maxCachedSessions : 0 , // Use Custom agent to disable session reuse (https://github.com/nodejs/node/issues/3940)
2021-07-30 16:11:14 +02:00
rejectUnauthorized : ! this . getIgnoreTls ( ) ,
} ) ,
2021-08-05 13:04:38 +02:00
maxRedirects : this . maxredirects ,
validateStatus : ( status ) => {
return checkStatusCode ( status , this . getAcceptedStatuscodes ( ) ) ;
} ,
2021-10-02 16:48:27 +02:00
} ;
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
2021-07-22 10:04:32 +02:00
// Check certificate if https is used
2021-07-23 06:58:05 +02:00
let certInfoStartTime = dayjs ( ) . valueOf ( ) ;
2021-07-22 10:13:58 +02:00
if ( this . getUrl ( ) ? . protocol === "https:" ) {
2021-07-23 06:58:05 +02:00
try {
2021-10-27 09:33:15 +02:00
let tlsInfoObject = checkCertificate ( res ) ;
tlsInfo = await this . updateTlsInfo ( tlsInfoObject ) ;
if ( ! this . getIgnoreTls ( ) ) {
debug ( "call sendCertNotification" ) ;
await this . sendCertNotification ( tlsInfoObject ) ;
}
2021-07-23 06:58:05 +02:00
} catch ( e ) {
2021-08-08 07:47:29 +02:00
if ( e . message !== "No TLS certificate in response" ) {
2021-09-17 08:42:19 +02:00
console . error ( e . message ) ;
2021-08-08 07:47:29 +02:00
}
2021-07-23 06:58:05 +02:00
}
2021-07-21 06:09:09 +02:00
}
2021-07-01 11:19:28 +02:00
2021-10-07 11:39:58 +02:00
if ( process . env . TIMELOGGER === "1" ) {
debug ( "Cert Info Query Time: " + ( dayjs ( ) . valueOf ( ) - certInfoStartTime ) + "ms" ) ;
}
2021-10-15 12:36:40 +02:00
if ( process . env . UPTIME _KUMA _LOG _RESPONSE _BODY _MONITOR _ID == this . id ) {
console . log ( res . data ) ;
}
2021-07-23 06:58:05 +02:00
2021-07-01 11:19:28 +02:00
if ( this . type === "http" ) {
2021-07-24 05:42:14 +02:00
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" ;
2021-07-24 05:42:14 +02:00
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 = "" ;
2021-07-24 05:42:14 +02:00
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 = "" ;
2021-07-24 05:42:14 +02:00
bean . status = UP ;
2021-08-23 00:05:48 +02:00
} else if ( this . type === "dns" ) {
let startTime = dayjs ( ) . valueOf ( ) ;
2021-08-23 00:05:48 +02:00
let dnsMessage = "" ;
2021-08-23 00:05:48 +02:00
2021-08-23 00:05:48 +02:00
let dnsRes = await dnsResolve ( this . hostname , this . dns _resolve _server , this . dns _resolve _type ) ;
bean . ping = dayjs ( ) . valueOf ( ) - startTime ;
2021-08-23 00:05:48 +02:00
2021-08-25 09:31:42 +02:00
if ( this . dns _resolve _type == "A" || this . dns _resolve _type == "AAAA" || this . dns _resolve _type == "TXT" ) {
2021-08-24 11:47:12 +02:00
dnsMessage += "Records: " ;
2021-08-25 09:31:42 +02:00
dnsMessage += dnsRes . join ( " | " ) ;
2021-08-24 11:47:12 +02:00
} else if ( this . dns _resolve _type == "CNAME" || this . dns _resolve _type == "PTR" ) {
2021-08-23 00:05:48 +02:00
dnsMessage = dnsRes [ 0 ] ;
2021-08-23 16:30:11 +02:00
} else if ( this . dns _resolve _type == "CAA" ) {
2021-08-23 00:05:48 +02:00
dnsMessage = dnsRes [ 0 ] . issue ;
2021-08-23 16:30:11 +02:00
} else if ( this . dns _resolve _type == "MX" ) {
2021-08-23 00:05:48 +02:00
dnsRes . forEach ( record => {
2021-08-24 11:47:12 +02:00
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 ) ;
2021-08-23 16:30:11 +02:00
} else if ( this . dns _resolve _type == "NS" ) {
2021-08-24 11:47:12 +02:00
dnsMessage += "Servers: " ;
2021-08-25 09:31:42 +02:00
dnsMessage += dnsRes . join ( " | " ) ;
2021-08-23 16:30:11 +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 } ` ;
2021-08-23 16:30:11 +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
const time = R . isoDateTime ( dayjs . utc ( ) . subtract ( this . interval , "second" ) ) ;
let heartbeatCount = await R . count ( "heartbeat" , " monitor_id = ? AND time > ? " , [
this . id ,
time
] ) ;
debug ( "heartbeatCount" + heartbeatCount + " " + time ) ;
if ( heartbeatCount <= 0 ) {
throw new Error ( "No heartbeat in the time window" ) ;
} else {
// No need to insert successful heartbeat for push type, so end here
retries = 0 ;
this . heartbeatInterval = setTimeout ( beat , this . interval * 1000 ) ;
return ;
}
2021-09-27 11:17:57 +02:00
} else if ( this . type === "steam" ) {
const steamApiUrl = "https://api.steampowered.com/IGameServersService/GetServerList/v1/" ;
2021-10-18 11:11:41 +02:00
const steamAPIKey = await setting ( "steamAPIKey" ) ;
2021-09-27 11:17:57 +02:00
const filter = ` addr \\ ${ this . hostname } : ${ this . port } ` ;
2021-10-18 11:11:41 +02:00
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)
rejectUnauthorized : ! this . getIgnoreTls ( ) ,
} ) ,
maxRedirects : this . maxredirects ,
validateStatus : ( status ) => {
return checkStatusCode ( status , this . getAcceptedStatuscodes ( ) ) ;
} ,
params : {
filter : filter ,
2021-10-18 11:11:41 +02:00
key : steamAPIKey ,
2021-09-27 11:17:57 +02:00
}
} ) ;
2021-10-18 11:02:05 +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
2021-10-18 11:02:05 +02:00
try {
bean . ping = await ping ( this . hostname ) ;
} catch ( _ ) { }
2021-09-27 11:17:57 +02:00
} else {
2021-10-18 11:02:05 +02:00
throw new Error ( "Server not found on Steam" ) ;
2021-09-27 11:17:57 +02:00
}
2021-10-18 11:02:05 +02:00
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
}
2021-07-30 18:01:04 +02:00
if ( this . isUpsideDown ( ) ) {
bean . status = flipStatus ( bean . status ) ;
if ( bean . status === DOWN ) {
throw new Error ( "Flip UP to DOWN" ) ;
}
}
2021-07-19 18:23:06 +02:00
retries = 0 ;
2021-06-27 10:10:55 +02:00
} catch ( error ) {
2021-07-30 18:01:04 +02: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 18:23:06 +02:00
retries ++ ;
2021-07-24 05:42:14 +02:00
bean . status = PENDING ;
2021-07-19 18:23:06 +02:00
}
2021-06-27 10:10:55 +02:00
}
2021-09-30 18:09:43 +02:00
let beatInterval = this . interval ;
2021-10-16 11:28:03 +02:00
let isImportant = Monitor . isImportantBeat ( isFirstBeat , previousBeat ? . status , bean . status ) ;
2021-07-24 05:42:14 +02:00
2021-07-20 11:50:33 +02:00
// Mark as important if status changed, ignore pending pings,
// Don't notify if disrupted changes to up
2021-07-24 05:42:14 +02:00
if ( isImportant ) {
2021-06-29 10:06:20 +02:00
bean . important = true ;
2021-10-14 16:32:15 +02:00
await Monitor . sendNotification ( isFirstBeat , this , bean ) ;
2021-10-27 05:39:46 +02:00
// Clear Status Page Cache
apicache . clear ( ) ;
2021-06-29 10:06:20 +02:00
} else {
bean . important = false ;
}
2021-07-24 05:42:14 +02:00
if ( bean . status === UP ) {
2021-09-17 08:42:19 +02:00
console . info ( ` Monitor # ${ this . id } ' ${ this . name } ': Successful Response: ${ bean . ping } ms | Interval: ${ beatInterval } seconds | Type: ${ this . type } ` ) ;
2021-07-24 05:42:14 +02:00
} else if ( bean . status === PENDING ) {
2021-09-29 11:20:35 +02:00
if ( this . retryInterval > 0 ) {
2021-09-11 18:54:55 +02:00
beatInterval = this . retryInterval ;
}
2021-09-17 08:42:19 +02: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-21 00:41:38 +02:00
} else {
2021-09-17 08:42:19 +02:00
console . warn ( ` Monitor # ${ this . id } ' ${ this . name } ': Failing: ${ bean . msg } | Interval: ${ beatInterval } seconds | Type: ${ this . type } ` ) ;
2021-07-21 00:41:38 +02:00
}
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
2021-08-23 12:52:24 +02:00
await R . store ( bean ) ;
prometheus . update ( bean , tlsInfo ) ;
2021-06-29 10:06:20 +02:00
previousBeat = bean ;
2021-08-23 12:52:24 +02:00
2021-09-08 14:00:16 +02:00
if ( ! this . isStop ) {
2021-10-09 20:23:27 +02:00
if ( demoMode ) {
if ( beatInterval < 20 ) {
2021-10-09 20:36:20 +02:00
console . log ( "beat interval too low, reset to 20s" ) ;
2021-10-09 20:23:27 +02:00
beatInterval = 20 ;
}
}
2021-10-27 08:08:44 +02:00
this . heartbeatInterval = setTimeout ( safeBeat , beatInterval * 1000 ) ;
2021-09-08 14:00:16 +02:00
}
2021-09-17 08:42:19 +02:00
} ;
2021-06-25 15:55:49 +02:00
2021-10-27 08:08:44 +02:00
const safeBeat = async ( ) => {
try {
await beat ( ) ;
} catch ( e ) {
console . trace ( e ) ;
2021-10-29 12:24:47 +02:00
errorLog ( e , false ) ;
2021-10-27 08:08:44 +02:00
console . error ( "Please report to https://github.com/louislam/uptime-kuma/issues" ) ;
if ( ! this . isStop ) {
console . log ( "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 ( ( ) => {
2021-10-27 08:08:44 +02:00
safeBeat ( ) ;
2021-09-30 18:09:43 +02:00
} , this . interval * 1000 ) ;
} else {
2021-10-27 08:08:44 +02:00
safeBeat ( ) ;
2021-09-30 18:09:43 +02:00
}
2021-06-25 15:55:49 +02:00
}
stop ( ) {
2021-08-23 12:52:24 +02:00
clearTimeout ( this . heartbeatInterval ) ;
2021-09-08 14:00:16 +02:00
this . isStop = true ;
2021-06-25 15:55:49 +02:00
}
2021-06-30 15:04:58 +02:00
2021-07-30 05:23:04 +02:00
/ * *
* Helper Method :
* returns URL object for further usage
* returns null if url is invalid
* @ returns { null | URL }
* /
2021-07-22 10:04:32 +02:00
getUrl ( ) {
try {
return new URL ( this . url ) ;
} catch ( _ ) {
return null ;
}
}
2021-07-30 05:23:04 +02:00
/ * *
* Store TLS info to database
* @ param checkCertificateResult
2021-08-10 11:51:30 +02:00
* @ returns { Promise < object > }
2021-07-30 05:23:04 +02:00
* /
2021-07-22 10:04:32 +02:00
async updateTlsInfo ( checkCertificateResult ) {
let tls _info _bean = await R . findOne ( "monitor_tls_info" , "monitor_id = ?" , [
2021-07-30 13:18:26 +02:00
this . id ,
2021-07-22 10:04:32 +02:00
] ) ;
2021-10-27 10:12:18 +02:00
2021-07-22 10:04:32 +02:00
if ( tls _info _bean == null ) {
tls _info _bean = R . dispense ( "monitor_tls_info" ) ;
tls _info _bean . monitor _id = this . id ;
2021-10-27 10:12:18 +02:00
} else {
2021-10-27 10:03:16 +02:00
2021-10-27 10:12:18 +02:00
// Clear sent history if the cert changed.
try {
let oldCertInfo = JSON . parse ( tls _info _bean . info _json ) ;
2021-10-27 10:03:16 +02:00
2021-10-27 10:12:18 +02:00
let isValidObjects = oldCertInfo && oldCertInfo . certInfo && checkCertificateResult && checkCertificateResult . certInfo ;
if ( isValidObjects ) {
if ( oldCertInfo . certInfo . fingerprint256 !== checkCertificateResult . certInfo . fingerprint256 ) {
debug ( "Resetting sent_history" ) ;
await R . exec ( "DELETE FROM notification_sent_history WHERE type = 'certificate' AND monitor_id = ?" , [
this . id
] ) ;
} else {
debug ( "No need to reset sent_history" ) ;
debug ( oldCertInfo . certInfo . fingerprint256 ) ;
debug ( checkCertificateResult . certInfo . fingerprint256 ) ;
}
} else {
debug ( "Not valid object" ) ;
}
} catch ( e ) { }
2021-10-27 10:03:16 +02:00
}
2021-07-22 10:04:32 +02:00
tls _info _bean . info _json = JSON . stringify ( checkCertificateResult ) ;
2021-07-23 06:58:05 +02:00
await R . store ( tls _info _bean ) ;
2021-08-10 11:51:30 +02:00
return checkCertificateResult ;
2021-07-22 10:04:32 +02:00
}
2021-06-30 15:04:58 +02:00
static async sendStats ( io , monitorID , userID ) {
2021-08-30 08:55:33 +02: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 15:04:58 +02:00
}
2021-07-01 07:11:16 +02:00
/ * *
*
* @ param duration : int Hours
* /
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 ) ;
}
2021-07-22 10:04:32 +02:00
static async sendCertInfo ( io , monitorID , userID ) {
2021-07-30 13:18:26 +02:00
let tls _info = await R . findOne ( "monitor_tls_info" , "monitor_id = ?" , [
monitorID ,
2021-07-22 10:04:32 +02:00
] ) ;
if ( tls _info != null ) {
io . to ( userID ) . emit ( "certInfo" , monitorID , tls _info . info _json ) ;
}
2021-07-21 06:09:09 +02:00
}
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
2021-07-01 07:11:16 +02:00
* @ param duration : int Hours
* /
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 ;
2021-09-09 09:55:34 +02:00
let uptime = 0 ;
2021-07-01 07:11:16 +02:00
2021-09-09 09:55:34 +02:00
if ( totalDuration > 0 ) {
uptime = uptimeDuration / totalDuration ;
if ( uptime < 0 ) {
uptime = 0 ;
}
2021-07-11 14:07:03 +02:00
2021-09-09 09:55:34 +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
2021-09-09 09:55:34 +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 duration : int Hours
* /
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
}
2021-10-07 11:39:58 +02:00
2021-10-14 16:32:15 +02:00
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 ;
}
static async sendNotification ( isFirstBeat , monitor , bean ) {
if ( ! isFirstBeat || bean . status === DOWN ) {
2021-10-27 09:33:15 +02:00
const notificationList = await Monitor . getNotificationList ( monitor ) ;
2021-10-14 16:32:15 +02:00
let text ;
if ( bean . status === UP ) {
text = "✅ Up" ;
} else {
text = "🔴 Down" ;
}
let msg = ` [ ${ monitor . name } ] [ ${ text } ] ${ bean . msg } ` ;
for ( let notification of notificationList ) {
try {
await Notification . send ( JSON . parse ( notification . config ) , msg , await monitor . toJSON ( ) , bean . toJSON ( ) ) ;
} catch ( e ) {
console . error ( "Cannot send notification to " + notification . name ) ;
console . log ( e ) ;
}
}
}
}
2021-10-27 09:33:15 +02:00
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 ;
}
async sendCertNotification ( tlsInfoObject ) {
if ( tlsInfoObject && tlsInfoObject . certInfo && tlsInfoObject . certInfo . daysRemaining ) {
const notificationList = await Monitor . getNotificationList ( this ) ;
debug ( "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 ) ;
}
}
async sendCertNotificationByTargetDays ( daysRemaining , targetDays , notificationList ) {
if ( daysRemaining > targetDays ) {
debug ( ` 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 ) {
debug ( "Sent already, no need to send again" ) ;
return ;
}
let sent = false ;
debug ( "Send certificate notification" ) ;
for ( let notification of notificationList ) {
try {
debug ( "Sending to " + notification . name ) ;
2021-10-27 10:12:18 +02:00
await Notification . send ( JSON . parse ( notification . config ) , ` [ ${ this . name } ][ ${ this . url } ] Certificate will be expired in ${ daysRemaining } days ` ) ;
2021-10-27 09:33:15 +02:00
sent = true ;
} catch ( e ) {
console . error ( "Cannot send cert notification to " + notification . name ) ;
console . error ( e ) ;
}
}
if ( sent ) {
await R . exec ( "INSERT INTO notification_sent_history (type, monitor_id, days) VALUES(?, ?, ?)" , [
"certificate" ,
this . id ,
targetDays ,
] ) ;
}
} else {
debug ( "No notification, no need to send cert notification" ) ;
}
}
2021-06-25 15:55:49 +02:00
}
module . exports = Monitor ;