@harperfast/harper-pro 5.0.6 → 5.0.7

package/dist/core/utility/environment/systemInformation.js

@@ -1,87 +1,25 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SystemInformationResponse = exports.SystemInformationRequest = void 0;
-exports.getTimeInfo = getTimeInfo;
-exports.getCPUInfo = getCPUInfo;
-exports.getMemoryInfo = getMemoryInfo;
-exports.getHDBProcessInfo = getHDBProcessInfo;
-exports.getDiskInfo = getDiskInfo;
-exports.getNetworkInfo = getNetworkInfo;
-exports.getSystemInformation = getSystemInformation;
-exports.getTableSize = getTableSize;
-exports.getMetrics = getMetrics;
-exports.systemInformation = systemInformation;
-const promises_1 = require("node:fs/promises");
-const node_path_1 = __importDefault(require("node:path"));
-const systeminformation_1 = __importDefault(require("systeminformation"));
-const harper_logger_js_1 = __importDefault(require("../logging/harper_logger.js"));
-const hdbTerms = __importStar(require("../hdbTerms.js"));
-const lmdbGetTableSize_ts_1 = require("../../dataLayer/harperBridge/lmdbBridge/lmdbUtility/lmdbGetTableSize.js");
-const manageThreads_js_1 = require("../../server/threads/manageThreads.js");
-const environmentManager_js_1 = __importDefault(require("./environmentManager.js"));
-const databases_ts_1 = require("../../resources/databases.js");
-const TableSizeObject_ts_1 = require("../../dataLayer/harperBridge/TableSizeObject.js");
-const rocksdb_js_1 = require("@harperfast/rocksdb-js");
-environmentManager_js_1.default.initSync();
+'use strict';
+const fs = require('fs-extra');
+const path = require('path');
+const si = require('systeminformation');
+const log = require('../logging/harper_logger.js');
+const terms = require("../hdbTerms.js");
+const lmdbGetTableSize = require('../../dataLayer/harperBridge/lmdbBridge/lmdbUtility/lmdbGetTableSize.js');
+const schemaDescribe = require('../../dataLayer/schemaDescribe.js');
+const { getThreadInfo } = require('../../server/threads/manageThreads.js');
+const env = require('./environmentManager.js');
+env.initSync();
+const { databases } = require("../../resources/databases.js");
 //this will hold the system_information which is static to improve performance
 let systemInformationCache = undefined;
 class SystemInformationRequest {
-    operator;
-    attributes;
     constructor(attributes) {
-        this.operator = hdbTerms.OPERATIONS_ENUM.SYSTEM_INFORMATION;
+        this.operator = terms.OPERATIONS_ENUM.SYSTEM_INFORMATION;
         this.attributes = attributes;
     }
 }
-exports.SystemInformationRequest = SystemInformationRequest;
 class SystemInformationResponse {
-    system;
-    time;
-    cpu;
-    memory;
-    disk;
-    network;
-    harperdb_processes;
-    table_size;
-    metrics;
-    threads;
-    constructor(system, time, cpu, memory, disk, network, harperdbProcesses, tableSize, metrics, threads) {
+    constructor(system, time, cpu, memory, disk, network, harperdbProcesses) {
         this.system = system;
         this.time = time;
         this.cpu = cpu;
@@ -89,150 +27,139 @@ class SystemInformationResponse {
         this.disk = disk;
         this.network = network;
         this.harperdb_processes = harperdbProcesses;
-        this.table_size = tableSize;
-        this.metrics = metrics;
-        this.threads = threads;
     }
 }
-exports.SystemInformationResponse = SystemInformationResponse;
+module.exports = {
+    getHDBProcessInfo,
+    getNetworkInfo,
+    getDiskInfo,
+    getMemoryInfo,
+    getCPUInfo,
+    getTimeInfo,
+    getSystemInformation,
+    systemInformation,
+    getTableSize,
+    getMetrics,
+    SystemInformationRequest,
+};
 /**
- * Returns the current local time, uptime, timezone, and timezone name.
+ * executes the time function to return the time info for the system
+ * @returns {si.Systeminformation.TimeData}
  */
 function getTimeInfo() {
-    return systeminformation_1.default.time();
+    return si.time();
 }
 /**
- * Detects CPU information such as manufacturer, brand, vendor, speed, cores, physical cores, and
- * processors.
+ * executes cpu related functions
+ * @returns {Promise<{}|Pick<si.Systeminformation.CpuData, "manufacturer" | "brand" | "vendor" | "speed" | "cores" | "physicalCores" | "processors">>}
  */
 async function getCPUInfo() {
     try {
-        const [cpu, cpu_speed, loadInfo] = await Promise.all([systeminformation_1.default.cpu(), systeminformation_1.default.cpuCurrentSpeed(), systeminformation_1.default.currentLoad()]);
-        const { manufacturer, brand, vendor, speed, cores, physicalCores, performanceCores, efficiencyCores, processors, flags, virtualization, } = cpu;
-        const { avgLoad, cpus, currentLoad, currentLoadUser, currentLoadSystem, currentLoadNice, currentLoadIdle, currentLoadIrq, } = loadInfo;
-        return {
-            manufacturer,
-            brand,
-            vendor,
-            speed,
-            cores,
-            physicalCores,
-            performanceCores,
-            efficiencyCores,
-            processors,
-            flags,
-            virtualization,
-            cpu_speed,
-            current_load: {
-                avgLoad,
-                cpus: cpus.map(({ load, loadUser, loadSystem, loadNice, loadIdle, loadIrq }) => ({
-                    load,
-                    loadUser,
-                    loadSystem,
-                    loadNice,
-                    loadIdle,
-                    loadIrq,
-                })),
-                currentLoad,
-                currentLoadUser,
-                currentLoadSystem,
-                currentLoadNice,
-                currentLoadIdle,
-                currentLoadIrq,
-            },
-        };
+        // eslint-disable-next-line no-unused-vars
+        let { family, model, stepping, revision, voltage, speedmin, speedmax, governor, socket, cache, ...cpuInfo } = await si.cpu();
+        cpuInfo.cpu_speed = await si.cpuCurrentSpeed();
+        let { 
+        // eslint-disable-next-line no-unused-vars
+        rawCurrentload, cpus, ...cpuCurrentLoad } = await si.currentLoad();
+        cpuCurrentLoad.cpus = [];
+        cpus.forEach((cpuData) => {
+            // eslint-disable-next-line no-unused-vars
+            let { rawLoad, rawLoadIdle, rawLoadIrq, rawLoadNice, rawLoadSystem, rawLoadUser, ...cpuLoad } = cpuData;
+            cpuCurrentLoad.cpus.push(cpuLoad);
+        });
+        cpuInfo.current_load = cpuCurrentLoad;
+        return cpuInfo;
     }
     catch (e) {
-        harper_logger_js_1.default.error(`error in getCPUInfo: ${e}`);
-        return null;
+        log.error(`error in getCPUInfo: ${e}`);
+        return {};
     }
 }
 /**
- * Detect system and Node.js memory usage.
+ * fetches information related memory
+ * @returns {Promise<{}|Pick<si.Systeminformation.MemData, "total" | "free" | "used" | "active" | "available" | "swaptotal" | "swapused" | "swapfree">>}
  */
 async function getMemoryInfo() {
     try {
-        const { total, free, used, active, available, reclaimable, swaptotal, swapused, swapfree, writeback, dirty } = await systeminformation_1.default.mem();
-        return {
-            total,
-            free,
-            used,
-            active,
-            available,
-            reclaimable,
-            swaptotal,
-            swapused,
-            swapfree,
-            writeback,
-            dirty,
-            ...process.memoryUsage(),
-        };
+        // eslint-disable-next-line no-unused-vars
+        let { buffers, cached, slab, buffcache, ...memInfo } = await si.mem();
+        return Object.assign(memInfo, process.memoryUsage());
     }
     catch (e) {
-        harper_logger_js_1.default.error(`error in getMemoryInfo: ${e}`);
-        return null;
-    }
-}
-async function getHdbPid() {
-    try {
-        return Number.parseInt(await (0, promises_1.readFile)(node_path_1.default.join(environmentManager_js_1.default.get(hdbTerms.CONFIG_PARAMS.ROOTPATH), hdbTerms.HDB_PID_FILE), 'utf8'));
-    }
-    catch (err) {
-        if (err.code === hdbTerms.NODE_ERROR_CODES.ENOENT) {
-            harper_logger_js_1.default.warn(`Unable to locate 'hdb.pid' file, try stopping and starting Harper. This could be because Harper is not running.`);
-        }
-        else {
-            throw err;
-        }
+        log.error(`error in getMemoryInfo: ${e}`);
+        return {};
     }
 }
 /**
- * Detects the Harper process PID and returns the process info.
+ * searches for & returns the processes for hdb core
  * @returns {Promise<{core: []}>}
  */
 async function getHDBProcessInfo() {
-    const harperdbProcesses = {
+    let harperdbProcesses = {
         core: [],
     };
     try {
-        const [processes, hdbPid] = await Promise.all([systeminformation_1.default.processes(), getHdbPid()]);
-        const proc = processes.list.find((p) => p.pid === hdbPid);
-        if (proc) {
-            harperdbProcesses.core.push(proc);
+        let processes = await si.processes();
+        let hdbPid;
+        try {
+            hdbPid = Number.parseInt(await fs.readFile(path.join(env.get(terms.CONFIG_PARAMS.ROOTPATH), terms.HDB_PID_FILE), 'utf8'));
         }
+        catch (err) {
+            if (err.code === terms.NODE_ERROR_CODES.ENOENT) {
+                log.warn(`Unable to locate 'hdb.pid' file, try stopping and starting Harper. This could be because Harper is not running.`);
+            }
+            else {
+                throw err;
+            }
+        }
+        processes.list.forEach((p) => {
+            if (p.pid === hdbPid) {
+                harperdbProcesses.core.push(p);
+            }
+        });
+        for (const hdbP of harperdbProcesses.core) {
+            for (const p of processes.list) {
+                if (p.pid === hdbP.parentPid && (p.name === 'PM2' || p.command === 'PM2')) {
+                    hdbP.parent = 'PM2';
+                }
+            }
+        }
+        return harperdbProcesses;
     }
     catch (e) {
-        harper_logger_js_1.default.error(`error in getHDBProcessInfo: ${e}`);
+        log.error(`error in getHDBProcessInfo: ${e}`);
+        return harperdbProcesses;
     }
-    return harperdbProcesses;
 }
 /**
- * Retrieves disk related info & stats
- * @returns {Promise<DiskInfo>}
+ * gets disk related info & stats
+ * @returns {Promise<{}>}
  */
 async function getDiskInfo() {
-    const disk = {};
+    let disk = {};
     try {
-        if (!environmentManager_js_1.default.get(hdbTerms.CONFIG_PARAMS.OPERATIONSAPI_SYSINFO_DISK))
+        if (!env.get(terms.CONFIG_PARAMS.OPERATIONSAPI_SYSINFO_DISK))
             return disk;
-        const [disksIO, fsStats, fsSize] = await Promise.all([systeminformation_1.default.disksIO(), systeminformation_1.default.fsStats(), systeminformation_1.default.fsSize()]);
-        const { rIO, wIO, tIO } = disksIO;
-        disk.io = { rIO, wIO, tIO };
-        const { rx, tx, wx } = fsStats;
-        disk.read_write = { rx, tx, wx };
-        disk.size = fsSize;
+        // eslint-disable-next-line no-unused-vars
+        let { rIO_sec, wIO_sec, tIO_sec, ms, ...diskIo } = await si.disksIO();
+        disk.io = diskIo;
+        // eslint-disable-next-line no-unused-vars
+        let { rxSec, txSec, wxSec, ...fsStats } = await si.fsStats();
+        disk.read_write = fsStats;
+        disk.size = await si.fsSize();
+        return disk;
     }
     catch (e) {
-        harper_logger_js_1.default.error(`error in getDiskInfo: ${e}`);
+        log.error(`error in getDiskInfo: ${e}`);
+        return disk;
     }
-    return disk;
 }
 /**
- * Detects networking connection information & stats
+ * gets networking & connection information & stats
  * @returns {Promise<{interfaces: [], default_interface: null, stats: [], latency: {}, connections: []}>}
  */
 async function getNetworkInfo() {
-    const network = {
+    let network = {
         default_interface: null,
         latency: {},
         interfaces: [],
@@ -240,227 +167,160 @@ async function getNetworkInfo() {
         connections: [],
     };
     try {
-        if (!environmentManager_js_1.default.get(hdbTerms.CONFIG_PARAMS.OPERATIONSAPI_SYSINFO_NETWORK))
+        if (!env.get(terms.CONFIG_PARAMS.OPERATIONSAPI_SYSINFO_NETWORK))
             return network;
-        const [defaultInterface, latency, nInterfaces, stats] = await Promise.all([
-            systeminformation_1.default.networkInterfaceDefault(),
-            systeminformation_1.default.inetChecksite('https://google.com').catch(() => ({})),
-            systeminformation_1.default.networkInterfaces(),
-            systeminformation_1.default.networkStats(),
-        ]);
-        network.default_interface = defaultInterface || null;
-        network.latency = latency;
-        for (const nInterface of nInterfaces) {
-            const { iface, ifaceName, default: isDefault, ip4, ip4subnet, ip6, ip6subnet, mac, operstate, type, duplex, speed, } = nInterface;
-            network.interfaces.push({
-                iface,
-                ifaceName,
-                default: isDefault,
-                ip4,
-                ip4subnet,
-                ip6,
-                ip6subnet,
-                mac,
-                operstate,
-                type,
-                duplex,
-                speed,
-            });
-        }
-        for (const nStat of stats) {
-            const { iface, operstate, rx_bytes, rx_dropped, rx_errors, tx_bytes, tx_dropped, tx_errors } = nStat;
-            network.stats.push({ iface, operstate, rx_bytes, rx_dropped, rx_errors, tx_bytes, tx_dropped, tx_errors });
-        }
+        network.default_interface = await si.networkInterfaceDefault();
+        network.latency = await si.inetChecksite('google.com');
+        let nInterfaces = await si.networkInterfaces();
+        nInterfaces.forEach((_interface) => {
+            // eslint-disable-next-line no-unused-vars
+            let { internal, virtual, mtu, dhcp, dnsSuffix, ieee8021xAuth, ieee8021xState, carrierChanges, ...networkInt } = _interface;
+            network.interfaces.push(networkInt);
+        });
+        let stats = await si.networkStats();
+        stats.forEach((nStat) => {
+            // eslint-disable-next-line no-unused-vars
+            let { rxSec, txSec, ms, ...stat } = nStat;
+            network.stats.push(stat);
+        });
+        return network;
     }
     catch (e) {
-        harper_logger_js_1.default.error(`error in getNetworkInfo: ${e}`);
+        log.error(`error in getNetworkInfo: ${e}`);
+        return network;
     }
-    return network;
 }
 /**
- * Detect operating system and Node.js runtime information.
- * @returns {Promise<SystemInfo>}
+ * gets system information
+ * @returns {Promise<Pick<si.Systeminformation.OsData, "platform" | "distro" | "release" | "codename" | "kernel" | "arch" | "hostname">|{}>}
  */
 async function getSystemInformation() {
     if (systemInformationCache !== undefined) {
         return systemInformationCache;
     }
-    let systemInfo = {};
+    let system_info = {};
     try {
-        const [osInfo, versions] = await Promise.all([systeminformation_1.default.osInfo(), systeminformation_1.default.versions('node, npm')]);
-        const { platform, distro, release, codename, kernel, arch, hostname, fqdn } = osInfo;
-        const { node, npm } = versions;
-        systemInfo = {
-            platform,
-            distro,
-            release,
-            codename,
-            kernel,
-            arch,
-            hostname,
-            fqdn,
-            node_version: node,
-            npm_version: npm,
-        };
-        systemInformationCache = systemInfo;
+        // eslint-disable-next-line no-unused-vars
+        let { codepage, logofile, serial, build, servicepack, uefi, ...sysInfo } = await si.osInfo();
+        system_info = sysInfo;
+        let versions = await si.versions('node, npm');
+        system_info.node_version = versions.node;
+        system_info.npm_version = versions.npm;
+        systemInformationCache = system_info;
+        return systemInformationCache;
     }
     catch (e) {
-        harper_logger_js_1.default.error(`error in getSystemInformation: ${e}`);
+        log.error(`error in getSystemInformation: ${e}`);
+        return system_info;
     }
-    return systemInfo;
 }
-function rocksdbGetTableSize(table) {
-    const rocksdb = table.primaryStore;
-    const stats = rocksdb.getStats();
-    const transactionLogSize = rocksdb
-        .listLogs()
-        .reduce((sum, logName) => sum + rocksdb.useLog(logName).getLogFileSize(), 0);
-    return new TableSizeObject_ts_1.TableSizeObject(table.databaseName, table.tableName, stats['rocksdb.estimate-live-data-size'] ?? 0, stats['rocksdb.estimate-num-keys'] ?? 0, transactionLogSize
-    // transactionLogRecordCount - currently not supported by `rocksdb-js`
-    );
-}
-/**
- * Retrieves table size information.
- * @returns {TableSizeObject[]}
- */
-function getTableSize() {
-    const results = [];
-    const databases = (0, databases_ts_1.getDatabases)();
-    for (const db of Object.values(databases)) {
-        for (const table of Object.values(db)) {
-            if (table.primaryStore.rootStore instanceof rocksdb_js_1.RocksDatabase) {
-                results.push(rocksdbGetTableSize(table));
-            }
-            else {
-                results.push((0, lmdbGetTableSize_ts_1.lmdbGetTableSize)(table));
-            }
+async function getTableSize() {
+    //get details for all tables
+    let tableSizes = [];
+    let allSchemas = await schemaDescribe.describeAll();
+    for (const tables of Object.values(allSchemas)) {
+        for (const tableData of Object.values(tables)) {
+            tableSizes.push(await lmdbGetTableSize(tableData));
         }
     }
-    return results;
+    return tableSizes;
 }
-const rocksDBDatabaseLevelStats = new Set([
-    'blockCacheCapacity',
-    'blockCacheDataHit',
-    'blockCacheDataMiss',
-    'blockCacheFilterHit',
-    'blockCacheFilterMiss',
-    'blockCacheHit',
-    'blockCacheIndexHit',
-    'blockCacheIndexMiss',
-    'blockCacheMiss',
-    'blockCachePinnedUsage',
-    'blockCacheUsage',
-    'bytesRead',
-    'bytesWritten',
-    'dbFlushMicros',
-    'dbGetMicros',
-    'dbSeekMicros',
-    'dbWriteMicros',
-    'noFileErrors',
-    'numberKeysRead',
-    'numberKeysWritten',
-    'numberReseeksIteration',
-    'numRunningFlushes',
-    'oldestSnapshotTime',
-    'stallMicros',
-    'txnOverheadMutexOldCommitMap',
-    'txnOverheadMutexPrepare',
-    'txnOverheadMutexSnapshot',
-]);
-// Strips the "rocksdb." prefix and converts kebab-case to camelCase
-function toRocksDBCamelCase(key) {
-    return key.replace(/^rocksdb\./, '').replace(/[-.]([a-z])/g, (_, c) => c.toUpperCase());
-}
-function getRocksDBStats(table, dbStats) {
-    const stats = table.primaryStore.getStats();
-    const tableStats = (dbStats.tables[table.tableName] = {});
-    for (const [key, value] of Object.entries(stats)) {
-        const name = toRocksDBCamelCase(key);
-        if (rocksDBDatabaseLevelStats.has(name)) {
-            dbStats[name] = value;
-        }
-        else {
-            tableStats[name] = value;
-        }
-    }
-}
-function getLMDBStats(table, dbStats) {
-    if (!dbStats.readers) {
-        const { root: _root, ...stats } = table.primaryStore.rootStore.getStats();
-        Object.assign(dbStats, stats);
-        dbStats.readers = table.primaryStore.rootStore
-            .readerList()
-            .split(/\n\s+/)
-            .slice(1)
-            .map((line) => {
-            const [pid, thread, txnid] = line.trim().split(' ');
-            return { pid, thread, txnid };
-        });
-        if (table.auditStore) {
-            const { treeDepth, treeBranchPageCount, treeLeafPageCount, entryCount, overflowPages } = table.auditStore.getStats();
-            dbStats.audit = { treeDepth, treeBranchPageCount, treeLeafPageCount, entryCount, overflowPages };
-        }
-    }
-    const { entryCount, overflowPages, treeBranchPageCount, treeDepth, treeLeafPageCount } = table.primaryStore.getStats();
-    dbStats.tables[table.tableName] = { entryCount, overflowPages, treeBranchPageCount, treeDepth, treeLeafPageCount };
-}
-/**
- * Get RocksDB or LMDB metrics for all databases and tables.
- * @returns {Promise<DatabaseMetrics>}
- */
 async function getMetrics() {
-    const databaseStats = {};
-    const databases = (0, databases_ts_1.getDatabases)();
-    for (const [dbName, db] of Object.entries(databases)) {
-        const dbStats = { tables: {} };
-        databaseStats[dbName] = dbStats;
-        for (const [tableName, table] of Object.entries(db)) {
+    let schemaStats = {};
+    for (let schemaName in databases) {
+        let dbStats = (schemaStats[schemaName] = {});
+        let tableStats = (dbStats.tables = {});
+        for (let tableName in databases[schemaName]) {
             try {
-                if (table.primaryStore.rootStore instanceof rocksdb_js_1.RocksDatabase) {
-                    getRocksDBStats(table, dbStats);
+                let table = databases[schemaName][tableName];
+                if (!dbStats.readers) {
+                    Object.assign(dbStats, table.primaryStore.rootStore.getStats());
+                    delete dbStats.root;
+                    dbStats.readers = table.primaryStore.rootStore
+                        .readerList()
+                        .split(/\n\s+/)
+                        .slice(1)
+                        .map((line) => {
+                        const [pid, thread, txnid] = line.trim().split(' ');
+                        return { pid, thread, txnid };
+                    });
+                    if (table.auditStore) {
+                        const { treeDepth, treeBranchPageCount, treeLeafPageCount, entryCount, overflowPages } = table.auditStore.getStats();
+                        dbStats.audit = { treeDepth, treeBranchPageCount, treeLeafPageCount, entryCount, overflowPages };
+                    }
                 }
-                else {
-                    getLMDBStats(table, dbStats);
+                let tableFullStats = table.primaryStore.getStats();
+                let tablePrunedStats = {};
+                for (let storeKey of ['treeDepth', 'treeBranchPageCount', 'treeLeafPageCount', 'entryCount', 'overflowPages']) {
+                    tablePrunedStats[storeKey] = tableFullStats[storeKey];
                 }
+                tableStats[tableName] = tablePrunedStats;
             }
             catch (error) {
-                // if a database no longer exists, don't want to throw an error
-                harper_logger_js_1.default.notify(`Error getting stats for table ${tableName}: ${error}`);
+                // if a schema no longer exists, don't want to throw an error
+                log.notify(`Error getting stats for table ${tableName}: ${error}`);
             }
         }
     }
-    return databaseStats;
+    return schemaStats;
 }
-const attributeMap = {
-    system: getSystemInformation,
-    time: getTimeInfo,
-    cpu: getCPUInfo,
-    memory: getMemoryInfo,
-    disk: getDiskInfo,
-    network: getNetworkInfo,
-    harperdb_processes: getHDBProcessInfo,
-    table_size: getTableSize,
-    metrics: getMetrics,
-    threads: manageThreads_js_1.getThreadInfo,
-};
 /**
- * Retrieves system information for the requested attributes.
+ *
  * @param {SystemInformationRequest} systemInfoReq
  * @returns {Promise<SystemInformationResponse>}
  */
 async function systemInformation(systemInfoReq) {
-    const attributes = Array.isArray(systemInfoReq.attributes) && systemInfoReq.attributes.length > 0
-        ? systemInfoReq.attributes
-        : Object.keys(attributeMap);
-    const response = new SystemInformationResponse();
-    await Promise.all(attributes
-        .filter((attr) => attr in attributeMap)
-        .map(async (attr) => {
-        if (attr === 'database_metrics') {
-            attr = 'metrics';
+    let response = new SystemInformationResponse();
+    if (!Array.isArray(systemInfoReq.attributes) || systemInfoReq.attributes.length === 0) {
+        response.system = await getSystemInformation();
+        response.time = getTimeInfo();
+        response.cpu = await getCPUInfo();
+        response.memory = await getMemoryInfo();
+        response.disk = await getDiskInfo();
+        response.network = await getNetworkInfo();
+        response.harperdb_processes = await getHDBProcessInfo();
+        response.table_size = await getTableSize();
+        response.metrics = await getMetrics();
+        response.threads = await getThreadInfo();
+        return response;
+    }
+    for (let attr of systemInfoReq.attributes) {
+        switch (attr) {
+            case 'system':
+                response.system = await getSystemInformation();
+                break;
+            case 'time':
+                response.time = getTimeInfo();
+                break;
+            case 'cpu':
+                response.cpu = await getCPUInfo();
+                break;
+            case 'memory':
+                response.memory = await getMemoryInfo();
+                break;
+            case 'disk':
+                response.disk = await getDiskInfo();
+                break;
+            case 'network':
+                response.network = await getNetworkInfo();
+                break;
+            case 'harperdb_processes':
+                response.harperdb_processes = await getHDBProcessInfo();
+                break;
+            case 'table_size':
+                response.table_size = await getTableSize();
+                break;
+            case 'database_metrics':
+            case 'metrics':
+                response.metrics = await getMetrics();
+                break;
+            case 'threads':
+                response.threads = await getThreadInfo();
+                break;
+            default:
+                break;
         }
-        response[attr] = await attributeMap[attr]();
-    }));
+    }
     return response;
 }
 //# sourceMappingURL=systemInformation.js.map