@harperfast/harper 5.0.6 → 5.0.8

package/dist/utility/environment/systemInformation.js

@@ -1,25 +1,87 @@
-'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");
+"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();
 //this will hold the system_information which is static to improve performance
 let systemInformationCache = undefined;
 class SystemInformationRequest {
+    operator;
+    attributes;
     constructor(attributes) {
-        this.operator = terms.OPERATIONS_ENUM.SYSTEM_INFORMATION;
+        this.operator = hdbTerms.OPERATIONS_ENUM.SYSTEM_INFORMATION;
         this.attributes = attributes;
     }
 }
+exports.SystemInformationRequest = SystemInformationRequest;
 class SystemInformationResponse {
-    constructor(system, time, cpu, memory, disk, network, harperdbProcesses) {
+    system;
+    time;
+    cpu;
+    memory;
+    disk;
+    network;
+    harperdb_processes;
+    table_size;
+    metrics;
+    threads;
+    constructor(system, time, cpu, memory, disk, network, harperdbProcesses, tableSize, metrics, threads) {
         this.system = system;
         this.time = time;
         this.cpu = cpu;
@@ -27,139 +89,150 @@ class SystemInformationResponse {
         this.disk = disk;
         this.network = network;
         this.harperdb_processes = harperdbProcesses;
+        this.table_size = tableSize;
+        this.metrics = metrics;
+        this.threads = threads;
     }
 }
-module.exports = {
-    getHDBProcessInfo,
-    getNetworkInfo,
-    getDiskInfo,
-    getMemoryInfo,
-    getCPUInfo,
-    getTimeInfo,
-    getSystemInformation,
-    systemInformation,
-    getTableSize,
-    getMetrics,
-    SystemInformationRequest,
-};
+exports.SystemInformationResponse = SystemInformationResponse;
 /**
- * executes the time function to return the time info for the system
- * @returns {si.Systeminformation.TimeData}
+ * Returns the current local time, uptime, timezone, and timezone name.
  */
 function getTimeInfo() {
-    return si.time();
+    return systeminformation_1.default.time();
 }
 /**
- * executes cpu related functions
- * @returns {Promise<{}|Pick<si.Systeminformation.CpuData, "manufacturer" | "brand" | "vendor" | "speed" | "cores" | "physicalCores" | "processors">>}
+ * Detects CPU information such as manufacturer, brand, vendor, speed, cores, physical cores, and
+ * processors.
  */
 async function getCPUInfo() {
     try {
-        // 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;
+        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,
+            },
+        };
     }
     catch (e) {
-        log.error(`error in getCPUInfo: ${e}`);
-        return {};
+        harper_logger_js_1.default.error(`error in getCPUInfo: ${e}`);
+        return null;
     }
 }
 /**
- * fetches information related memory
- * @returns {Promise<{}|Pick<si.Systeminformation.MemData, "total" | "free" | "used" | "active" | "available" | "swaptotal" | "swapused" | "swapfree">>}
+ * Detect system and Node.js memory usage.
  */
 async function getMemoryInfo() {
     try {
-        // eslint-disable-next-line no-unused-vars
-        let { buffers, cached, slab, buffcache, ...memInfo } = await si.mem();
-        return Object.assign(memInfo, process.memoryUsage());
+        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(),
+        };
     }
     catch (e) {
-        log.error(`error in getMemoryInfo: ${e}`);
-        return {};
+        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;
+        }
     }
 }
 /**
- * searches for & returns the processes for hdb core
+ * Detects the Harper process PID and returns the process info.
  * @returns {Promise<{core: []}>}
  */
 async function getHDBProcessInfo() {
-    let harperdbProcesses = {
+    const harperdbProcesses = {
         core: [],
     };
     try {
-        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'));
+        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);
         }
-        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) {
-        log.error(`error in getHDBProcessInfo: ${e}`);
-        return harperdbProcesses;
+        harper_logger_js_1.default.error(`error in getHDBProcessInfo: ${e}`);
     }
+    return harperdbProcesses;
 }
 /**
- * gets disk related info & stats
- * @returns {Promise<{}>}
+ * Retrieves disk related info & stats
+ * @returns {Promise<DiskInfo>}
  */
 async function getDiskInfo() {
-    let disk = {};
+    const disk = {};
     try {
-        if (!env.get(terms.CONFIG_PARAMS.OPERATIONSAPI_SYSINFO_DISK))
+        if (!environmentManager_js_1.default.get(hdbTerms.CONFIG_PARAMS.OPERATIONSAPI_SYSINFO_DISK))
             return disk;
-        // 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;
+        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;
     }
     catch (e) {
-        log.error(`error in getDiskInfo: ${e}`);
-        return disk;
+        harper_logger_js_1.default.error(`error in getDiskInfo: ${e}`);
     }
+    return disk;
 }
 /**
- * gets networking & connection information & stats
+ * Detects networking connection information & stats
  * @returns {Promise<{interfaces: [], default_interface: null, stats: [], latency: {}, connections: []}>}
  */
 async function getNetworkInfo() {
-    let network = {
+    const network = {
         default_interface: null,
         latency: {},
         interfaces: [],
@@ -167,160 +240,227 @@ async function getNetworkInfo() {
         connections: [],
     };
     try {
-        if (!env.get(terms.CONFIG_PARAMS.OPERATIONSAPI_SYSINFO_NETWORK))
+        if (!environmentManager_js_1.default.get(hdbTerms.CONFIG_PARAMS.OPERATIONSAPI_SYSINFO_NETWORK))
             return network;
-        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;
+        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 });
+        }
     }
     catch (e) {
-        log.error(`error in getNetworkInfo: ${e}`);
-        return network;
+        harper_logger_js_1.default.error(`error in getNetworkInfo: ${e}`);
     }
+    return network;
 }
 /**
- * gets system information
- * @returns {Promise<Pick<si.Systeminformation.OsData, "platform" | "distro" | "release" | "codename" | "kernel" | "arch" | "hostname">|{}>}
+ * Detect operating system and Node.js runtime information.
+ * @returns {Promise<SystemInfo>}
  */
 async function getSystemInformation() {
     if (systemInformationCache !== undefined) {
         return systemInformationCache;
     }
-    let system_info = {};
+    let systemInfo = {};
     try {
-        // 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;
+        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;
     }
     catch (e) {
-        log.error(`error in getSystemInformation: ${e}`);
-        return system_info;
+        harper_logger_js_1.default.error(`error in getSystemInformation: ${e}`);
     }
+    return systemInfo;
 }
-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));
+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));
+            }
         }
     }
-    return tableSizes;
+    return results;
 }
+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() {
-    let schemaStats = {};
-    for (let schemaName in databases) {
-        let dbStats = (schemaStats[schemaName] = {});
-        let tableStats = (dbStats.tables = {});
-        for (let tableName in databases[schemaName]) {
+    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)) {
             try {
-                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 };
-                    }
+                if (table.primaryStore.rootStore instanceof rocksdb_js_1.RocksDatabase) {
+                    getRocksDBStats(table, dbStats);
                 }
-                let tableFullStats = table.primaryStore.getStats();
-                let tablePrunedStats = {};
-                for (let storeKey of ['treeDepth', 'treeBranchPageCount', 'treeLeafPageCount', 'entryCount', 'overflowPages']) {
-                    tablePrunedStats[storeKey] = tableFullStats[storeKey];
+                else {
+                    getLMDBStats(table, dbStats);
                 }
-                tableStats[tableName] = tablePrunedStats;
             }
             catch (error) {
-                // if a schema no longer exists, don't want to throw an error
-                log.notify(`Error getting stats for table ${tableName}: ${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}`);
             }
         }
     }
-    return schemaStats;
+    return databaseStats;
 }
+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) {
-    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;
+    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';
         }
-    }
+        response[attr] = await attributeMap[attr]();
+    }));
     return response;
 }
 //# sourceMappingURL=systemInformation.js.map