@resolveio/server-lib 9.0.34 → 9.0.35

package/methods/monitor.js

@@ -1,333 +1,392 @@
-import { MonitorMongos } from '../collections/monitor-mongo.collection';
-import { MonitorCPUs } from '../collections/monitor-cpu.collection';
-import { MonitorHTTPSOutbounds } from '../collections/monitor-https-outbound.collection';
-import { MonitorHTTPSInbounds } from '../collections/monitor-https-inbound.collection';
-import { MonitorMemorys } from '../collections/monitor-memory.collection';
-import { ResolveIOServer } from '..';
-import { deepCopy } from '../util/common';
-export function loadMonitorMethods(methodManager) {
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadMonitorMethods = void 0;
+var monitor_mongo_collection_1 = require("../collections/monitor-mongo.collection");
+var monitor_cpu_collection_1 = require("../collections/monitor-cpu.collection");
+var monitor_https_outbound_collection_1 = require("../collections/monitor-https-outbound.collection");
+var monitor_https_inbound_collection_1 = require("../collections/monitor-https-inbound.collection");
+var monitor_memory_collection_1 = require("../collections/monitor-memory.collection");
+var __1 = require("..");
+var common_1 = require("../util/common");
+function loadMonitorMethods(methodManager) {
     methodManager.methods({
         superadminMonitor: {
             skipQueue: true,
             function: function (date_start, date_end, collection, instance, client, graphInterval, variable, variableType) {
-                return new Promise(async (resolve, reject) => {
-                    let groupId = {};
-                    let groupDate = {};
-                    if (graphInterval === 'seconds') {
-                        groupId = {
-                            second: {
-                                $second: {
-                                    date: '$date',
-                                    timezone: "America/Chicago"
-                                }
-                            },
-                            minute: {
-                                $minute: {
-                                    date: '$date',
-                                    timezone: "America/Chicago"
-                                }
-                            },
-                            hour: {
-                                $hour: {
-                                    date: '$date',
-                                    timezone: "America/Chicago"
-                                }
-                            },
-                            day: {
-                                $dayOfMonth: {
-                                    date: '$date',
-                                    timezone: "America/Chicago"
-                                }
-                            },
-                            month: {
-                                $month: {
-                                    date: '$date',
-                                    timezone: "America/Chicago"
-                                }
-                            },
-                            year: {
-                                $year: {
-                                    date: '$date',
-                                    timezone: "America/Chicago"
-                                }
-                            },
-                            client: '$client',
-                            instance: '$instance'
-                        };
-                        groupDate = {
-                            'year': '$_id.year',
-                            'month': '$_id.month',
-                            'day': '$_id.day',
-                            'hour': '$_id.hour',
-                            'minute': '$_id.minute',
-                            'second': '$_id.second',
-                            [variable]: '$' + variable
-                        };
-                    }
-                    else if (graphInterval === 'minutes') {
-                        groupId = {
-                            minute: {
-                                $minute: {
-                                    date: '$date',
-                                    timezone: "America/Chicago"
-                                }
-                            },
-                            hour: {
-                                $hour: {
-                                    date: '$date',
-                                    timezone: "America/Chicago"
-                                }
-                            },
-                            day: {
-                                $dayOfMonth: {
-                                    date: '$date',
-                                    timezone: "America/Chicago"
+                var _this = this;
+                return new Promise(function (resolve, reject) { return __awaiter(_this, void 0, void 0, function () {
+                    var groupId, groupDate, query, firstGroupId, graphData;
+                    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
+                    return __generator(this, function (_p) {
+                        switch (_p.label) {
+                            case 0:
+                                groupId = {};
+                                groupDate = {};
+                                if (graphInterval === 'seconds') {
+                                    groupId = {
+                                        second: {
+                                            $second: {
+                                                date: '$date',
+                                                timezone: "America/Chicago"
+                                            }
+                                        },
+                                        minute: {
+                                            $minute: {
+                                                date: '$date',
+                                                timezone: "America/Chicago"
+                                            }
+                                        },
+                                        hour: {
+                                            $hour: {
+                                                date: '$date',
+                                                timezone: "America/Chicago"
+                                            }
+                                        },
+                                        day: {
+                                            $dayOfMonth: {
+                                                date: '$date',
+                                                timezone: "America/Chicago"
+                                            }
+                                        },
+                                        month: {
+                                            $month: {
+                                                date: '$date',
+                                                timezone: "America/Chicago"
+                                            }
+                                        },
+                                        year: {
+                                            $year: {
+                                                date: '$date',
+                                                timezone: "America/Chicago"
+                                            }
+                                        },
+                                        client: '$client',
+                                        instance: '$instance'
+                                    };
+                                    groupDate = (_a = {
+                                            'year': '$_id.year',
+                                            'month': '$_id.month',
+                                            'day': '$_id.day',
+                                            'hour': '$_id.hour',
+                                            'minute': '$_id.minute',
+                                            'second': '$_id.second'
+                                        },
+                                        _a[variable] = '$' + variable,
+                                        _a);
                                 }
-                            },
-                            month: {
-                                $month: {
-                                    date: '$date',
-                                    timezone: "America/Chicago"
+                                else if (graphInterval === 'minutes') {
+                                    groupId = {
+                                        minute: {
+                                            $minute: {
+                                                date: '$date',
+                                                timezone: "America/Chicago"
+                                            }
+                                        },
+                                        hour: {
+                                            $hour: {
+                                                date: '$date',
+                                                timezone: "America/Chicago"
+                                            }
+                                        },
+                                        day: {
+                                            $dayOfMonth: {
+                                                date: '$date',
+                                                timezone: "America/Chicago"
+                                            }
+                                        },
+                                        month: {
+                                            $month: {
+                                                date: '$date',
+                                                timezone: "America/Chicago"
+                                            }
+                                        },
+                                        year: {
+                                            $year: {
+                                                date: '$date',
+                                                timezone: "America/Chicago"
+                                            }
+                                        },
+                                        client: '$client',
+                                        instance: '$instance'
+                                    };
+                                    groupDate = (_b = {
+                                            'year': '$_id.year',
+                                            'month': '$_id.month',
+                                            'day': '$_id.day',
+                                            'hour': '$_id.hour',
+                                            'minute': '$_id.minute'
+                                        },
+                                        _b[variable] = '$' + variable,
+                                        _b);
                                 }
-                            },
-                            year: {
-                                $year: {
-                                    date: '$date',
-                                    timezone: "America/Chicago"
+                                else if (graphInterval === 'hours') {
+                                    groupId = {
+                                        hour: {
+                                            $hour: {
+                                                date: '$date',
+                                                timezone: "America/Chicago"
+                                            }
+                                        },
+                                        day: {
+                                            $dayOfMonth: {
+                                                date: '$date',
+                                                timezone: "America/Chicago"
+                                            }
+                                        },
+                                        month: {
+                                            $month: {
+                                                date: '$date',
+                                                timezone: "America/Chicago"
+                                            }
+                                        },
+                                        year: {
+                                            $year: {
+                                                date: '$date',
+                                                timezone: "America/Chicago"
+                                            }
+                                        },
+                                        client: '$client',
+                                        instance: '$instance'
+                                    };
+                                    groupDate = (_c = {
+                                            'year': '$_id.year',
+                                            'month': '$_id.month',
+                                            'day': '$_id.day',
+                                            'hour': '$_id.hour'
+                                        },
+                                        _c[variable] = '$' + variable,
+                                        _c);
                                 }
-                            },
-                            client: '$client',
-                            instance: '$instance'
-                        };
-                        groupDate = {
-                            'year': '$_id.year',
-                            'month': '$_id.month',
-                            'day': '$_id.day',
-                            'hour': '$_id.hour',
-                            'minute': '$_id.minute',
-                            [variable]: '$' + variable
-                        };
-                    }
-                    else if (graphInterval === 'hours') {
-                        groupId = {
-                            hour: {
-                                $hour: {
-                                    date: '$date',
-                                    timezone: "America/Chicago"
+                                else {
+                                    groupId = {
+                                        day: {
+                                            $dayOfMonth: {
+                                                date: '$date',
+                                                timezone: "America/Chicago"
+                                            }
+                                        },
+                                        month: {
+                                            $month: {
+                                                date: '$date',
+                                                timezone: "America/Chicago"
+                                            }
+                                        },
+                                        year: {
+                                            $year: {
+                                                date: '$date',
+                                                timezone: "America/Chicago"
+                                            }
+                                        },
+                                        client: '$client',
+                                        instance: '$instance'
+                                    };
+                                    groupDate = (_d = {
+                                            'year': '$_id.year',
+                                            'month': '$_id.month',
+                                            'day': '$_id.day'
+                                        },
+                                        _d[variable] = '$' + variable,
+                                        _d);
                                 }
-                            },
-                            day: {
-                                $dayOfMonth: {
-                                    date: '$date',
-                                    timezone: "America/Chicago"
-                                }
-                            },
-                            month: {
-                                $month: {
-                                    date: '$date',
-                                    timezone: "America/Chicago"
-                                }
-                            },
-                            year: {
-                                $year: {
-                                    date: '$date',
-                                    timezone: "America/Chicago"
-                                }
-                            },
-                            client: '$client',
-                            instance: '$instance'
-                        };
-                        groupDate = {
-                            'year': '$_id.year',
-                            'month': '$_id.month',
-                            'day': '$_id.day',
-                            'hour': '$_id.hour',
-                            [variable]: '$' + variable
-                        };
-                    }
-                    else {
-                        groupId = {
-                            day: {
-                                $dayOfMonth: {
-                                    date: '$date',
-                                    timezone: "America/Chicago"
-                                }
-                            },
-                            month: {
-                                $month: {
-                                    date: '$date',
-                                    timezone: "America/Chicago"
-                                }
-                            },
-                            year: {
-                                $year: {
-                                    date: '$date',
-                                    timezone: "America/Chicago"
-                                }
-                            },
-                            client: '$client',
-                            instance: '$instance'
-                        };
-                        groupDate = {
-                            'year': '$_id.year',
-                            'month': '$_id.month',
-                            'day': '$_id.day',
-                            [variable]: '$' + variable
-                        };
-                    }
-                    let query = [
-                        {
-                            $match: {
-                                $and: [
-                                    {
-                                        date: { $gte: date_start }
-                                    },
+                                query = [
                                     {
-                                        date: { $lte: date_end }
+                                        $match: {
+                                            $and: [
+                                                {
+                                                    date: { $gte: date_start }
+                                                },
+                                                {
+                                                    date: { $lte: date_end }
+                                                }
+                                            ]
+                                        }
                                     }
-                                ]
-                            }
-                        }
-                    ];
-                    if (client) {
-                        query[0]['$match'].$and.push({ client: client });
-                    }
-                    if (instance) {
-                        query[0]['$match'].$and.push({ instance: instance });
-                    }
-                    let firstGroupId = deepCopy(groupId);
-                    if (collection === 'monitor-mongos') {
-                        firstGroupId[variable] = '$' + variable;
-                        groupDate['data'] = '$data';
-                    }
-                    if (collection === 'monitor-mongos') {
-                        query.push({
-                            $group: {
-                                _id: firstGroupId,
-                                [variable]: {
-                                    '$sum': 1
-                                },
-                                [variable + '_name']: {
-                                    $first: '$' + [variable]
-                                },
-                                date: {
-                                    $first: '$date'
-                                },
-                                client: {
-                                    $first: '$client'
-                                },
-                                instance: {
-                                    $first: '$instance'
+                                ];
+                                if (client) {
+                                    query[0]['$match'].$and.push({ client: client });
                                 }
-                            }
-                        });
-                        query.push({
-                            $addFields: {
-                                data: {
-                                    [variable]: '$' + variable,
-                                    [variable + '_name']: '$' + variable + '_name'
+                                if (instance) {
+                                    query[0]['$match'].$and.push({ instance: instance });
                                 }
-                            }
-                        });
-                        query.push({
-                            $group: {
-                                _id: groupId,
-                                [variable]: {
-                                    '$sum': '$data.' + variable
-                                },
-                                data: {
-                                    $push: '$data'
+                                firstGroupId = common_1.deepCopy(groupId);
+                                if (collection === 'monitor-mongos') {
+                                    firstGroupId[variable] = '$' + variable;
+                                    groupDate['data'] = '$data';
                                 }
-                            }
-                        });
-                        query.push({
-                            $addFields: {
-                                [variable]: groupDate
-                            }
-                        });
-                        query.push({
-                            $group: {
-                                _id: {
-                                    client: '$_id.client',
-                                    instance: '$_id.instance'
-                                },
-                                data: {
-                                    $push: '$' + variable
-                                },
-                                [variable]: {
-                                    $sum: '$' + variable + '.' + variable
+                                if (collection === 'monitor-mongos') {
+                                    query.push({
+                                        $group: (_e = {
+                                                _id: firstGroupId
+                                            },
+                                            _e[variable] = {
+                                                '$sum': 1
+                                            },
+                                            _e[variable + '_name'] = {
+                                                $first: '$' + [variable]
+                                            },
+                                            _e.date = {
+                                                $first: '$date'
+                                            },
+                                            _e.client = {
+                                                $first: '$client'
+                                            },
+                                            _e.instance = {
+                                                $first: '$instance'
+                                            },
+                                            _e)
+                                    });
+                                    query.push({
+                                        $addFields: {
+                                            data: (_f = {},
+                                                _f[variable] = '$' + variable,
+                                                _f[variable + '_name'] = '$' + variable + '_name',
+                                                _f)
+                                        }
+                                    });
+                                    query.push({
+                                        $group: (_g = {
+                                                _id: groupId
+                                            },
+                                            _g[variable] = {
+                                                '$sum': '$data.' + variable
+                                            },
+                                            _g.data = {
+                                                $push: '$data'
+                                            },
+                                            _g)
+                                    });
+                                    query.push({
+                                        $addFields: (_h = {},
+                                            _h[variable] = groupDate,
+                                            _h)
+                                    });
+                                    query.push({
+                                        $group: (_j = {
+                                                _id: {
+                                                    client: '$_id.client',
+                                                    instance: '$_id.instance'
+                                                },
+                                                data: {
+                                                    $push: '$' + variable
+                                                }
+                                            },
+                                            _j[variable] = {
+                                                $sum: '$' + variable + '.' + variable
+                                            },
+                                            _j)
+                                    });
                                 }
-                            }
-                        });
-                    }
-                    else {
-                        query.push({
-                            $group: {
-                                _id: groupId,
-                                [variable]: {
-                                    ['$' + variableType]: '$' + variable
+                                else {
+                                    query.push({
+                                        $group: (_k = {
+                                                _id: groupId
+                                            },
+                                            _k[variable] = (_l = {},
+                                                _l['$' + variableType] = '$' + variable,
+                                                _l),
+                                            _k)
+                                    });
+                                    query.push({
+                                        $addFields: (_m = {},
+                                            _m[variable] = groupDate,
+                                            _m)
+                                    });
+                                    query.push({
+                                        $group: (_o = {
+                                                _id: {
+                                                    client: '$_id.client',
+                                                    instance: '$_id.instance'
+                                                },
+                                                data: {
+                                                    $push: '$' + variable
+                                                }
+                                            },
+                                            _o[variable] = {
+                                                $sum: '$' + variable + '.' + variable
+                                            },
+                                            _o)
+                                    });
                                 }
-                            }
-                        });
-                        query.push({
-                            $addFields: {
-                                [variable]: groupDate
-                            }
-                        });
-                        query.push({
-                            $group: {
-                                _id: {
-                                    client: '$_id.client',
-                                    instance: '$_id.instance'
-                                },
-                                data: {
-                                    $push: '$' + variable
-                                },
-                                [variable]: {
-                                    $sum: '$' + variable + '.' + variable
-                                }
-                            }
-                        });
-                    }
-                    query.push({
-                        $sort: {
-                            '_id.client': 1,
-                            '_id.instance': 1
+                                query.push({
+                                    $sort: {
+                                        '_id.client': 1,
+                                        '_id.instance': 1
+                                    }
+                                });
+                                return [4 /*yield*/, __1.ResolveIOServer.getMongoManager().collection(collection).aggregate(query, { allowDiskUse: true })];
+                            case 1:
+                                graphData = _p.sent();
+                                resolve(graphData);
+                                return [2 /*return*/];
                         }
                     });
-                    // console.log(JSON.stringify(query, null, 2));
-                    let graphData = await ResolveIOServer.getMongoManager().collection(collection).aggregate(query, { allowDiskUse: true });
-                    resolve(graphData);
-                });
+                }); });
             },
             skipValidation: true
         },
         monitorMongos: {
             function: function () {
-                return MonitorMongos.find();
+                return monitor_mongo_collection_1.MonitorMongos.find();
             }
         },
         monitorCPUs: {
             function: function () {
-                return MonitorCPUs.find();
+                return monitor_cpu_collection_1.MonitorCPUs.find();
             }
         },
         monitorMemorys: {
             function: function () {
-                return MonitorMemorys.find();
+                return monitor_memory_collection_1.MonitorMemorys.find();
             }
         },
         monitorHTTPSOutbounds: {
             function: function () {
-                return MonitorHTTPSOutbounds.find();
+                return monitor_https_outbound_collection_1.MonitorHTTPSOutbounds.find();
             }
         },
         monitorHTTPSInbounds: {
             function: function () {
-                return MonitorHTTPSInbounds.find();
+                return monitor_https_inbound_collection_1.MonitorHTTPSInbounds.find();
             }
         },
     });
 }
+exports.loadMonitorMethods = loadMonitorMethods;
 
 //# sourceMappingURL=monitor.js.map