@resolveio/server-lib 9.0.32 → 9.0.34

package/methods/monitor.js

@@ -1,392 +1,333 @@
-"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) {
+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) {
     methodManager.methods({
         superadminMonitor: {
             skipQueue: true,
             function: function (date_start, date_end, collection, instance, client, graphInterval, variable, variableType) {
-                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);
+                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"
                                 }
-                                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);
+                            },
+                            month: {
+                                $month: {
+                                    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);
+                            },
+                            year: {
+                                $year: {
+                                    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);
+                            },
+                            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"
                                 }
-                                query = [
+                            },
+                            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 }
+                                    },
                                     {
-                                        $match: {
-                                            $and: [
-                                                {
-                                                    date: { $gte: date_start }
-                                                },
-                                                {
-                                                    date: { $lte: date_end }
-                                                }
-                                            ]
-                                        }
+                                        date: { $lte: date_end }
                                     }
-                                ];
-                                if (client) {
-                                    query[0]['$match'].$and.push({ client: client });
+                                ]
+                            }
+                        }
+                    ];
+                    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 (instance) {
-                                    query[0]['$match'].$and.push({ instance: instance });
+                            }
+                        });
+                        query.push({
+                            $addFields: {
+                                data: {
+                                    [variable]: '$' + variable,
+                                    [variable + '_name']: '$' + variable + '_name'
                                 }
-                                firstGroupId = common_1.deepCopy(groupId);
-                                if (collection === 'monitor-mongos') {
-                                    firstGroupId[variable] = '$' + variable;
-                                    groupDate['data'] = '$data';
+                            }
+                        });
+                        query.push({
+                            $group: {
+                                _id: groupId,
+                                [variable]: {
+                                    '$sum': '$data.' + variable
+                                },
+                                data: {
+                                    $push: '$data'
                                 }
-                                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)
-                                    });
+                            }
+                        });
+                        query.push({
+                            $addFields: {
+                                [variable]: groupDate
+                            }
+                        });
+                        query.push({
+                            $group: {
+                                _id: {
+                                    client: '$_id.client',
+                                    instance: '$_id.instance'
+                                },
+                                data: {
+                                    $push: '$' + variable
+                                },
+                                [variable]: {
+                                    $sum: '$' + variable + '.' + 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)
-                                    });
+                            }
+                        });
+                    }
+                    else {
+                        query.push({
+                            $group: {
+                                _id: groupId,
+                                [variable]: {
+                                    ['$' + variableType]: '$' + variable
                                 }
-                                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*/];
+                            }
+                        });
+                        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
                         }
                     });
-                }); });
+                    // 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 monitor_mongo_collection_1.MonitorMongos.find();
+                return MonitorMongos.find();
             }
         },
         monitorCPUs: {
             function: function () {
-                return monitor_cpu_collection_1.MonitorCPUs.find();
+                return MonitorCPUs.find();
             }
         },
         monitorMemorys: {
             function: function () {
-                return monitor_memory_collection_1.MonitorMemorys.find();
+                return MonitorMemorys.find();
             }
         },
         monitorHTTPSOutbounds: {
             function: function () {
-                return monitor_https_outbound_collection_1.MonitorHTTPSOutbounds.find();
+                return MonitorHTTPSOutbounds.find();
             }
         },
         monitorHTTPSInbounds: {
             function: function () {
-                return monitor_https_inbound_collection_1.MonitorHTTPSInbounds.find();
+                return MonitorHTTPSInbounds.find();
             }
         },
     });
 }
-exports.loadMonitorMethods = loadMonitorMethods;
 
 //# sourceMappingURL=monitor.js.map