@resolveio/server-lib 12.5.53 → 12.5.54

package/src/managers/monitor.manager.ts

@@ -0,0 +1,323 @@
+import ResolveIOMainServer from '../server-app';
+import axios from 'axios';
+import { MonitorCPUs } from '../collections/monitor-cpu.collection';
+import { MonitorMemorys } from '../collections/monitor-memory.collection';
+import { MonitorMongos } from '../collections/monitor-mongo.collection';
+import { ResolveIOServer } from '../index';
+import { deepCopy } from '../util/common';
+import { objectIdHexString } from './mongo.manager';
+const os = require('os');
+
+export class MonitorManager {
+	private _mainServer: ResolveIOMainServer;
+	private _serverConfig;
+	private _instanceHostname = '';
+	private _monitorData = [];
+
+	constructor(mainServer, serverConfig) {
+		this._mainServer = mainServer;
+		this._serverConfig = serverConfig;
+		this._instanceHostname = os.hostname().replace(/\./g, '-');
+
+		this.setupIntervals();
+		this.setupEventLoop();
+	}
+
+	//Create function to get CPU information
+	cpuAverage() {
+		//Initialise sum of idle and time of cores and fetch CPU info
+		var totalIdle = 0, totalTick = 0;
+		var cpus = os.cpus();
+	
+		//Loop through CPU cores
+		for(var i = 0, len = cpus.length; i < len; i++) {
+			//Select CPU core
+			var cpu = cpus[i];
+		
+			//Total up the time in the cores tick
+			for(let type in cpu.times) {
+				totalTick += cpu.times[type];
+			}
+		
+			//Total up the idle time of the core
+			totalIdle += cpu.times.idle;
+		}
+	
+		//Return the average Idle and Tick times
+		return {idle: totalIdle / cpus.length,  total: totalTick / cpus.length};
+	}
+
+	async setupIntervals() {
+		if (this._serverConfig['ROOT_URL'] !== 'https://resolveio.com' && this._serverConfig['ROOT_URL'] !== 'http://localhost:4200') {
+			try {
+				let instanceId = await axios.get('http://169.254.169.254/latest/meta-data/instance-id');
+
+				setInterval(async () => {
+					try {
+						await axios.post('https://backend.resolveio.com/api/health', {
+							type: 'application',
+							id_aws_instance: instanceId.data,
+							version: typeof process.env.APP_VERSION === 'number' ? (<any>process.env.APP_VERSION).toString() : process.env.APP_VERSION,
+							version_key: process.env.APP_VERSION_KEY
+						});
+					}
+					catch(e) {}
+				}, 10000);
+			}
+			catch(errHealth) {}
+		}
+
+		let lastCPU = this.cpuAverage();
+		
+		setInterval(() => {
+			let now = new Date();
+
+			//Grab second Measure
+			var endMeasure = this.cpuAverage(); 
+
+			//Calculate the difference in idle and total time between the measures
+			var idleDifference = endMeasure.idle - lastCPU.idle;
+			var totalDifference = endMeasure.total - lastCPU.total;
+
+			//Calculate the average percentage CPU usage
+			var percentageCPU = 1 - idleDifference / totalDifference;
+			
+			if (this._serverConfig['ROOT_URL'] === 'https://resolveio.com' || this._serverConfig['ROOT_URL'] === 'http://localhost:4200') {
+				MonitorCPUs.create({
+					_id: objectIdHexString(),
+					metadata: {
+						instance: this._instanceHostname,
+						client: this._serverConfig['CLIENT_NAME']
+					},
+					date: now,
+					app: percentageCPU,
+					system: os.loadavg()[0]
+				});
+			}
+			else {
+				this._monitorData.push({
+					metadata: {
+						instance: this._instanceHostname,
+						client: this._serverConfig['CLIENT_NAME']
+					},
+					date: now,
+					app: percentageCPU,
+					system: os.loadavg()[0],
+					type: 'cpu'
+				})
+			}
+
+			lastCPU = endMeasure;
+
+			const memUsage = process.memoryUsage();
+
+			if (this._serverConfig['ROOT_URL'] === 'https://resolveio.com' || this._serverConfig['ROOT_URL'] === 'http://localhost:4200') {
+				MonitorMemorys.create({
+					_id: objectIdHexString(),
+					metadata: {
+						instance: this._instanceHostname,
+						client: this._serverConfig['CLIENT_NAME']
+					},
+					date: now,
+					physical_total: memUsage.heapTotal,
+					physical_used: memUsage.heapUsed,
+					physical_free: os.freemem(),
+					virtual: memUsage.rss,
+					private: memUsage.external,
+					physical: os.totalmem()
+				});
+			}
+			else {
+				this._monitorData.push({
+					metadata: {
+						instance: this._instanceHostname,
+						client: this._serverConfig['CLIENT_NAME']
+					},
+					date: now,
+					physical_total: memUsage.heapTotal,
+					physical_used: memUsage.heapUsed,
+					physical_free: os.freemem(),
+					virtual: memUsage.rss,
+					private: memUsage.external,
+					physical: os.totalmem(),
+					type: 'memory'
+				});
+			}
+		}, 3000);
+	}
+
+	
+
+	addMongoTracker(data: MongoMonitorModel) {
+		if (this._serverConfig['ROOT_URL'] === 'https://resolveio.com' || this._serverConfig['ROOT_URL'] === 'http://localhost:4200') {
+			if (!data.collection.startsWith('monitor-')) {
+				MonitorMongos.create({
+					_id: objectIdHexString(),
+					metadata: {
+						instance: this._instanceHostname,
+						client: this._serverConfig['CLIENT_NAME']
+					},
+					date: new Date(data.date),
+					method: data.method,
+					doc_collection: data.collection,
+					duration: data.duration,
+					query: Buffer.byteLength(data.query, 'utf8') < 15800000 ? data.query : 'Too Big'
+				});
+			}
+		}
+		else {
+			if (this._instanceHostname) {
+				if (this._serverConfig['ROOT_URL'] !== 'https://airdropxrp.io' && this._serverConfig['ROOT_URL'] !== 'https://xrptradereport.com') {
+					this._monitorData.push({
+						metadata: {
+							instance: this._instanceHostname,
+							client: this._serverConfig['CLIENT_NAME']
+						},
+						date: new Date(data.date),
+						method: data.method,
+						doc_collection: data.collection,
+						duration: data.duration,
+						query: Buffer.byteLength(data.query, 'utf8') < 15800000 ? data.query : 'Too Big',
+						type: 'mongo'
+					});
+				}
+			}
+		}	
+	}
+
+	setupEventLoop() {
+		setInterval(async () => {
+			if (this._monitorData.length) {
+				let monitorData = this._monitorData.splice(0, Math.min(10, this._monitorData.length));
+
+				try {
+					await axios.post('https://backend.resolveio.com/api/monitor', monitorData);
+				}
+				catch (e) {}
+			}
+		}, 1000);
+	}
+}
+
+export interface MongoMonitorModel {
+	date: Date, 
+	method: string,
+	collection: string,
+	duration: number,
+	query: string
+}
+
+export class MonitorMongo {
+	private _startTime = 0;
+	private _method = '';
+	private _collection = '';
+	private _query = '';
+
+	constructor(method: string, collection: string, query: string) {
+		this._startTime = Date.now();
+		this._method = method;
+		this._collection = collection;
+		this._query = query;
+	}
+
+	public finish() {
+		let endTime = Date.now();
+
+		let mongoMonitor: MongoMonitorModel = {
+			date: new Date(endTime),
+			method: this._method,
+			collection: this._collection,
+			query: this._query,
+			duration: endTime - this._startTime
+		};
+
+		ResolveIOServer.getMainServer().getMonitorManager().addMongoTracker(mongoMonitor);
+	}
+}
+
+export class MonitorManagerFunction {
+	private _functionCnt = 0;
+	private _functions: MonitorFunction[] = [];
+	private _functionLastCompletedWS: {
+		[id_socket: string]: MonitorFunction;
+	} = {};
+	private _functionLastCompleted: MonitorFunction;
+
+	constructor() {}
+
+	startMonitorFunction(functionType: MonitorFunctionType, functionName: string, user: string, id_socket: string, data: any) {
+		let newMonitorFunction = new MonitorFunction(this._functionCnt++, functionType, functionName, user, id_socket, data);
+		this._functions.push(newMonitorFunction);
+		return newMonitorFunction.id;
+	}
+
+	finishMonitorFunction(id: number) {
+		let monitor = this._functions.filter(a => a.id === id)[0];
+		if (monitor) {
+			monitor.finish();
+			this._functionLastCompleted = monitor;
+			this._functionLastCompletedWS[monitor.id_socket] = monitor;
+			this._functions.splice(this._functions.map(a => a.id).indexOf(id), 1);
+		}
+	}
+
+	getActiveMonitorFunctions() {
+		return this._functions;
+	}
+
+	getLastCompletedMonitorFunction() {
+		return this._functionLastCompleted;
+	}
+	
+	getLastCompletedMonitorFunctionWS() {
+		return this._functionLastCompletedWS;
+	}
+}
+
+export type MonitorFunctionType = 'Cron Method' | 'Internal Method' | 'Method' | 'User Specific Publication' | 'Publication';
+export class MonitorFunction {
+	private _timer: NodeJS.Timeout = null;
+	private _maxDiff = 0;
+	private _functionType: MonitorFunctionType;
+	private _functionName: string;
+	private _user: string;
+	private _data: any;
+	public startTime: Date = null;
+	public endTime: Date = null;
+	public lastTime: Date = null;
+	public id_socket = '';
+	public id = 0;
+
+	constructor(id: number, functionType: MonitorFunctionType, functionName: string, user: string, id_socket: string, data: any) {
+		this.id = id;
+		this.startTime = new Date();
+		this._functionType = functionType;
+		this._functionName = functionName;
+		this._user = user;
+		this.id_socket = id_socket;
+		this._data = data;
+		this.lastTime = new Date();
+
+		this._timer = setInterval(() => {
+			let diff = Date.now() - this.lastTime.getTime();
+			if (diff > this._maxDiff) {
+				this._maxDiff = diff;
+			}
+
+			this.lastTime = new Date();
+		}, 1000);
+	}
+
+	public finish() {
+		if (this._timer) {
+			clearInterval(this._timer);
+			this._timer = null;
+		}
+
+		this.endTime = new Date();
+
+		if (this._maxDiff >= 5000) {
+			ResolveIOServer.getMainServer().getMethodManager().sendEmail('dev@resolveio.com', ResolveIOServer.getMainServer().getServerConfig()['CLIENT_NAME'] + ' - Slow ' + this._functionType + ' Detected', '', (this._user ? 'User: ' + this._user + '\n' : '') + this._functionType + ': ' + this._functionName + '\n' + 'During this function the event loop did not run for ' + this._maxDiff + ' ms (' + this._maxDiff / 1000 + ' sec)' + (this._data ? '\n\nData: ' + JSON.stringify(this._data, null, 2) : ''));
+		}
+	}
+}