@oas-tools/oas-telemetry 0.7.0-alpha.0 → 0.7.0-alpha.2

package/dist/cjs/tlmRoutes.cjs

@@ -32,7 +32,9 @@ const configureRoutes = router => {
     if (req.body !== undefined) {
       return next(); // Already parsed, no need to parse again.
     }
-    return (0, _express.json)()(req, res, next);
+    return (0, _express.json)({
+      limit: '10mb'
+    })(req, res, next);
   });
   const allAuthMiddlewares = getWrappedMiddlewares(() => _config.globalOasTlmConfig.authEnabled, [(0, _cookieParser.default)(), _authRoutes.default, _authMiddleware.authMiddleware]);
   const baseURL = _config.globalOasTlmConfig.baseURL;

package/dist/esm/exporters/InMemoryDBMetricsExporter.js

@@ -9,8 +9,8 @@ export class InMemoryDBMetricsExporter {
     export(metrics, resultCallback) {
         try {
             if (!this._stopped) {
-                // metrics = metrics?.scopeMetrics;
-                const cleanMetrics = applyNesting(metrics);
+                const scopeMetrics = metrics?.scopeMetrics;
+                const cleanMetrics = applyNesting(scopeMetrics);
                 this._metrics.insert(cleanMetrics, (err, _newDoc) => {
                     if (err) {
                         console.error('Insertion Error:', err);
@@ -54,4 +54,12 @@ export class InMemoryDBMetricsExporter {
     getFinishedMetrics() {
         return this._metrics.getAllData();
     }
+    /**
+     * Inserts metrics into the in-memory database.
+     * @param metrics - The metrics to insert.
+     * @param callback - The callback to execute after insertion.
+     */
+    insert(metrics, callback) {
+        this._metrics.insert(metrics, callback);
+    }
 }

package/dist/esm/exporters/InMemoryDbExporter.js

@@ -3,6 +3,7 @@ import { ExportResultCode } from '@opentelemetry/core';
 import dataStore from '@seald-io/nedb';
 import logger from '../utils/logger.js';
 import { applyNesting, removeCircularRefs } from '../utils/circular.js';
+import { globalOasTlmConfig } from '../config.js';
 export class InMemoryExporter {
     constructor() {
         // Overrided by dynamic exporter
@@ -18,7 +19,13 @@ export class InMemoryExporter {
                 const cleanSpans = readableSpans
                     .map(nestedSpan => removeCircularRefs(nestedSpan)) // to avoid JSON parsing error
                     .map(span => applyNesting(span)) // to avoid dot notation in keys (neDB does not support dot notation in keys)
-                    .filter(span => !span?.attributes?.http?.target?.includes("/telemetry")); // to avoid telemetry spans
+                    .filter(span => {
+                    const target = span?.attributes?.http?.target; // Exclude spans where target includes 'telemetry' but NOT 'telemetry/utils'
+                    if (target && target.includes(globalOasTlmConfig.baseURL)) {
+                        return target.includes(globalOasTlmConfig.baseURL + '/utils');
+                    }
+                    return true;
+                });
                 // Insert spans into the in-memory database
                 this._spans.insert(cleanSpans, (err, _newDoc) => {
                     // p = {name, plugin
@@ -84,4 +91,12 @@ export class InMemoryExporter {
         return this._spans.getAllData();
     }
     ;
+    /**
+     * Inserts spans into the in-memory database.
+     * @param spans - The spans to insert.
+     * @param callback - The callback to execute after insertion.
+     */
+    insert(spans, callback) {
+        this._spans.insert(spans, callback);
+    }
 }

package/dist/esm/exporters/InMemoryLogRecordExporter.js

@@ -11,6 +11,7 @@ export class InMemoryLogRecordExporter {
             storeFields: ['_id'],
             idField: '_id',
         });
+        this._stopped = false;
     }
     /*
     * SUPER WARNING:
@@ -24,6 +25,10 @@ export class InMemoryLogRecordExporter {
      * @param resultCallback
      */
     export(logs, resultCallback) {
+        if (this._stopped) {
+            resultCallback({ code: ExportResultCode.SUCCESS });
+            return;
+        }
         const logsToInsert = logs.map(logRecord => {
             // Remove circular references first, then apply nesting, then export info
             const formattedLog = this._formatLogRecord(logRecord);
@@ -31,16 +36,7 @@ export class InMemoryLogRecordExporter {
             const nestedLog = applyNesting(cleanedLog);
             return nestedLog;
         });
-        this._db.insert(logsToInsert, (err, newDocs) => {
-            if (err) {
-                console.dir(err);
-                resultCallback({ code: ExportResultCode.FAILED });
-                return;
-            }
-            // console.dir(newDocs, { depth: 3 });
-            newDocs.forEach((doc) => this._miniSearch.add(doc));
-            resultCallback({ code: ExportResultCode.SUCCESS });
-        });
+        this._insertLogs(logsToInsert, resultCallback);
     }
     reset() {
         this._db = new Datastore();
@@ -67,7 +63,33 @@ export class InMemoryLogRecordExporter {
         }
         this._db.find(query, callback);
     }
-    getFinishedSpans() {
+    insert(data, callback) {
+        this._insertLogs(data, (result) => {
+            if (result.code === ExportResultCode.SUCCESS) {
+                this._db.find({}, (err, docs) => {
+                    if (err) {
+                        console.dir(err);
+                        callback(err, []);
+                        return;
+                    }
+                    callback(null, docs);
+                });
+            }
+            else {
+                callback(new Error('Failed to insert logs'), []);
+            }
+        });
+    }
+    start() {
+        this._stopped = false;
+    }
+    stop() {
+        this._stopped = true;
+    }
+    isRunning() {
+        return !this._stopped;
+    }
+    getFinishedLogs() {
         return this._db.getAllData();
     }
     /**
@@ -92,4 +114,17 @@ export class InMemoryLogRecordExporter {
             attributes: logRecord.attributes,
         };
     }
+    _insertLogs(logsToInsert, resultCallback) {
+        this._db.insert(logsToInsert, (err, newDocs) => {
+            if (err) {
+                console.dir(err);
+                resultCallback({ code: ExportResultCode.FAILED });
+                return;
+            }
+            // console.dir(newDocs, { depth: 3 });
+            newDocs.forEach((doc) => this._miniSearch.add(doc));
+            resultCallback({ code: ExportResultCode.SUCCESS });
+        });
+        return;
+    }
 }

package/dist/esm/tlm-ai/tools.js

@@ -42,7 +42,7 @@ const getLogs = async (startDate, endDate) => {
         }
         const logs = [];
         await new Promise((resolve, reject) => {
-            globalOasTlmConfig.debugExporter.find(nedbQuery, null, (err, docs) => {
+            globalOasTlmConfig.logExporter.find(nedbQuery, null, (err, docs) => {
                 if (err) {
                     reject(err);
                 }
@@ -402,7 +402,7 @@ function getSimplifiedMetrics(metrics) {
                         // @ts-expect-error index signature
                         cpuUtilization[state] = stateSums[state] / stateCounts[state];
                     }
-                    cpuCount = Math.max(...metric.dataPoints.map((dp) => parseInt(dp.attributes?.system?.cpu?.debugical_number || 0, 10))) + 1;
+                    cpuCount = Math.max(...metric.dataPoints.map((dp) => parseInt(dp.attributes?.system?.cpu?.logical_number || 0, 10))) + 1;
                 }
                 if (name === 'system.memory.usage') {
                     for (const dp of metric.dataPoints) {

package/dist/esm/tlm-log/logController.js

@@ -1,7 +1,7 @@
 import { globalOasTlmConfig } from '../config.js';
 export const listLogs = async (req, res) => {
     try {
-        const logs = globalOasTlmConfig.logExporter.getFinishedSpans();
+        const logs = globalOasTlmConfig.logExporter.getFinishedLogs();
         res.send({ logsCount: logs.length, logs: logs });
     }
     catch (err) {
@@ -34,3 +34,50 @@ export const resetLogs = (req, res) => {
     globalOasTlmConfig.logExporter.reset();
     res.send('Logs reset');
 };
+export const insertLogsToDb = async (req, res) => {
+    const jsonContent = req.body.logs;
+    const resetData = req.query.reset === 'true';
+    if (!Array.isArray(jsonContent)) {
+        res.status(400).send({ error: 'Invalid data format. Expected an array of JSON objects.' });
+        return;
+    }
+    const cleanedLogs = jsonContent.map((log) => {
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const { _id, ...rest } = log; // Remove _id if it exists
+        return rest; // Return the cleaned log object
+    });
+    try {
+        let message = '';
+        if (resetData) {
+            globalOasTlmConfig.logExporter.reset();
+            message += 'Logs Database reset. ';
+        }
+        await new Promise((resolve, reject) => {
+            globalOasTlmConfig.logExporter.insert(cleanedLogs, (err, newDocs) => {
+                if (err) {
+                    console.error('Error inserting logs:', err);
+                    return reject(err);
+                }
+                resolve(newDocs);
+            });
+        });
+        message += `Inserted ${cleanedLogs.length} logs.`;
+        res.send({ message, InsertedLogsCount: cleanedLogs.length });
+    }
+    catch (err) {
+        console.error(err);
+        res.status(500).send({ error: 'Failed to reset and insert data', details: err.message });
+    }
+};
+export const startLogs = (req, res) => {
+    globalOasTlmConfig.logExporter.start();
+    res.send('Log collection started');
+};
+export const stopLogs = (req, res) => {
+    globalOasTlmConfig.logExporter.stop();
+    res.send('Log collection stopped');
+};
+export const statusLogs = (req, res) => {
+    const isRunning = globalOasTlmConfig.logExporter.isRunning() || false;
+    res.send({ active: isRunning });
+};

package/dist/esm/tlm-log/logRoutes.js

@@ -1,7 +1,12 @@
 import { Router } from 'express';
-import { listLogs, findLogs, resetLogs } from './logController.js';
+import { startLogs, stopLogs, statusLogs, resetLogs, listLogs, findLogs, insertLogsToDb } from './logController.js';
 export const logRoutes = Router();
+// Logs Control
+logRoutes.get('/start', startLogs);
+logRoutes.get('/stop', stopLogs);
+logRoutes.get('/status', statusLogs);
+logRoutes.get('/reset', resetLogs);
 logRoutes.get('/', listLogs);
+logRoutes.post('/', insertLogsToDb);
 logRoutes.post('/find', findLogs);
-logRoutes.get('/reset', resetLogs);
 export default logRoutes;

package/dist/esm/tlm-metric/metricsController.js

@@ -1,7 +1,7 @@
 import { globalOasTlmConfig } from '../config.js';
 export const listMetrics = async (req, res) => {
     try {
-        const metrics = await globalOasTlmConfig.metricsExporter.getFinishedMetrics();
+        const metrics = globalOasTlmConfig.metricsExporter.getFinishedMetrics();
         res.send({ metricsCount: metrics.length, metrics: metrics });
     }
     catch (err) {
@@ -26,3 +26,50 @@ export const resetMetrics = (req, res) => {
     globalOasTlmConfig.metricsExporter.reset();
     res.send('Metrics reset');
 };
+export const insertMetricsToDb = async (req, res) => {
+    const jsonContent = req.body.metrics;
+    const resetData = req.query.reset === 'true';
+    if (!Array.isArray(jsonContent)) {
+        res.status(400).send({ error: 'Invalid data format. Expected an array of JSON objects.' });
+        return;
+    }
+    const cleanedMetrics = jsonContent.map((metric) => {
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const { _id, ...rest } = metric; // Remove _id if it exists
+        return rest; // Return the cleaned metric object
+    });
+    try {
+        let message = '';
+        if (resetData) {
+            globalOasTlmConfig.metricsExporter.reset();
+            message += 'Metrics Database reset. ';
+        }
+        await new Promise((resolve, reject) => {
+            globalOasTlmConfig.metricsExporter.insert(cleanedMetrics, (err, newDocs) => {
+                if (err) {
+                    console.error('Error inserting metrics:', err);
+                    return reject(err);
+                }
+                resolve(newDocs);
+            });
+        });
+        message += `Inserted ${cleanedMetrics.length} metrics.`;
+        res.send({ message, InsertedMetricsCount: cleanedMetrics.length });
+    }
+    catch (err) {
+        console.error(err);
+        res.status(500).send({ error: 'Failed to reset and insert data', details: err.message });
+    }
+};
+export const startMetrics = (req, res) => {
+    globalOasTlmConfig.metricsExporter.start();
+    res.send('Metrics collection started');
+};
+export const stopMetrics = (req, res) => {
+    globalOasTlmConfig.metricsExporter.stop();
+    res.send('Metrics collection stopped');
+};
+export const statusMetrics = (req, res) => {
+    const isRunning = globalOasTlmConfig.metricsExporter.isRunning() || false;
+    res.send({ active: isRunning });
+};

package/dist/esm/tlm-metric/metricsRoutes.js

@@ -1,8 +1,12 @@
 import { Router } from 'express';
-import { listMetrics, findMetrics, resetMetrics } from './metricsController.js';
+import { listMetrics, findMetrics, resetMetrics, insertMetricsToDb, startMetrics, stopMetrics, statusMetrics } from './metricsController.js';
 export const metricsRoutes = Router();
 // Metrics Control
 metricsRoutes.get('/', listMetrics);
+metricsRoutes.post('/', insertMetricsToDb);
 metricsRoutes.post('/find', findMetrics);
 metricsRoutes.get('/reset', resetMetrics);
+metricsRoutes.get('/start', startMetrics);
+metricsRoutes.get('/stop', stopMetrics);
+metricsRoutes.get('/status', statusMetrics);
 export default metricsRoutes;

package/dist/esm/tlm-trace/traceController.js

@@ -52,3 +52,38 @@ export const findTelemetry = (req, res) => {
         res.send({ spansCount: spans.length, spans: spans });
     });
 };
+export const insertTracesToDb = async (req, res) => {
+    const jsonContent = req.body.spans;
+    const resetData = req.query.reset === 'true';
+    if (!Array.isArray(jsonContent)) {
+        res.status(400).send({ error: 'Invalid data format. Expected an array of JSON objects.' });
+        return;
+    }
+    const cleanedTraces = jsonContent.map((trace) => {
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const { _id, ...rest } = trace; // Remove _id if it exists
+        return rest; // Return the cleaned trace object
+    });
+    try {
+        let message = '';
+        if (resetData) {
+            globalOasTlmConfig.dynamicSpanExporter.exporter.reset();
+            message += 'Traces Database reset. ';
+        }
+        await new Promise((resolve, reject) => {
+            globalOasTlmConfig.dynamicSpanExporter.exporter.insert(cleanedTraces, (err, newDocs) => {
+                if (err) {
+                    console.error('Error inserting traces:', err);
+                    return reject(err);
+                }
+                resolve(newDocs);
+            });
+        });
+        message += `Inserted ${cleanedTraces.length} traces.`;
+        res.send({ message, InsertedTracesCount: cleanedTraces.length });
+    }
+    catch (err) {
+        console.error(err);
+        res.status(500).send({ error: 'Failed to reset and insert data', details: err.message });
+    }
+};

package/dist/esm/tlm-trace/traceRoutes.js

@@ -1,7 +1,8 @@
 import { Router } from 'express';
-import { startTelemetry, stopTelemetry, statusTelemetry, resetTelemetry, listTelemetry, findTelemetry } from './traceController.js';
+import { startTelemetry, stopTelemetry, statusTelemetry, resetTelemetry, listTelemetry, findTelemetry, insertTracesToDb } from './traceController.js';
 export const traceRoutes = Router();
 traceRoutes.get('/', listTelemetry);
+traceRoutes.post('/', insertTracesToDb);
 traceRoutes.post('/find', findTelemetry);
 // Telemetry Control
 traceRoutes.get('/start', startTelemetry);

package/dist/esm/tlm-util/utilRoutes.js

@@ -3,4 +3,15 @@ import { specLoader, heapStats } from './utilController.js';
 export const utilsRoutes = Router();
 utilsRoutes.get('/spec', specLoader);
 utilsRoutes.get('/heapStats', heapStats);
+utilsRoutes.get('/generateLog', (req, res) => {
+    const log = req.query.log || 'Default log message';
+    console.log('Generated log:', log);
+    res.send({ message: 'Log generated', log: log });
+});
+utilsRoutes.get('/wait/:seconds?', async (req, res) => {
+    const seconds = parseInt(req.params.seconds ?? "1", 10);
+    const waitTime = isNaN(seconds) ? 1 : seconds;
+    await new Promise(resolve => setTimeout(resolve, waitTime * 1000));
+    res.send({ waited: waitTime });
+});
 export default utilsRoutes;

package/dist/esm/tlmRoutes.js

@@ -24,7 +24,7 @@ export const configureRoutes = (router) => {
         if (req.body !== undefined) {
             return next(); // Already parsed, no need to parse again.
         }
-        return json()(req, res, next);
+        return json({ limit: '10mb' })(req, res, next);
     });
     const allAuthMiddlewares = getWrappedMiddlewares(() => globalOasTlmConfig.authEnabled, [cookieParser(), authRoutes, authMiddleware]);
     const baseURL = globalOasTlmConfig.baseURL;

package/dist/types/exporters/InMemoryDBMetricsExporter.d.ts

@@ -12,4 +12,10 @@ export declare class InMemoryDBMetricsExporter {
     find(search: any, callback: any): void;
     reset(): void;
     getFinishedMetrics(): import("@seald-io/nedb").Document<Record<string, any>>[];
+    /**
+     * Inserts metrics into the in-memory database.
+     * @param metrics - The metrics to insert.
+     * @param callback - The callback to execute after insertion.
+     */
+    insert(metrics: any[], callback: (err: any, newDocs: any[]) => void): void;
 }

package/dist/types/exporters/InMemoryDbExporter.d.ts

@@ -21,4 +21,10 @@ export declare class InMemoryExporter implements OasTlmExporter {
     find(search: any, callback: any): void;
     reset(): void;
     getFinishedSpans(): import("@seald-io/nedb").Document<Record<string, any>>[];
+    /**
+     * Inserts spans into the in-memory database.
+     * @param spans - The spans to insert.
+     * @param callback - The callback to execute after insertion.
+     */
+    insert(spans: any[], callback: (err: any, newDocs: any[]) => void): void;
 }

package/dist/types/exporters/InMemoryLogRecordExporter.d.ts

@@ -3,6 +3,7 @@ import { ReadableLogRecord, LogRecordExporter } from '@opentelemetry/sdk-logs';
 export declare class InMemoryLogRecordExporter implements LogRecordExporter {
     private _db;
     private _miniSearch;
+    private _stopped;
     constructor();
     /**
      * Export logs.
@@ -16,7 +17,11 @@ export declare class InMemoryLogRecordExporter implements LogRecordExporter {
      */
     shutdown(): Promise<void>;
     find(query: any, messageSearch: string | null, callback: (err: any, docs: any) => void): void;
-    getFinishedSpans(): any[];
+    insert(data: any[], callback: (err: any, newDocs: any[]) => void): void;
+    start(): void;
+    stop(): void;
+    isRunning(): boolean;
+    getFinishedLogs(): any[];
     /**
      *  @copyright The OpenTelemetry Authors
      *  @license Apache-2.0
@@ -24,4 +29,5 @@ export declare class InMemoryLogRecordExporter implements LogRecordExporter {
      * @param logRecord
      */
     private _formatLogRecord;
+    private _insertLogs;
 }

package/dist/types/tlm-log/logController.d.ts

@@ -2,3 +2,7 @@ import { Request, Response } from 'express';
 export declare const listLogs: (req: Request, res: Response) => Promise<void>;
 export declare const findLogs: (req: Request, res: Response) => Promise<void>;
 export declare const resetLogs: (req: Request, res: Response) => void;
+export declare const insertLogsToDb: (req: Request, res: Response) => Promise<void>;
+export declare const startLogs: (req: Request, res: Response) => void;
+export declare const stopLogs: (req: Request, res: Response) => void;
+export declare const statusLogs: (req: Request, res: Response) => void;

package/dist/types/tlm-metric/metricsController.d.ts

@@ -2,3 +2,7 @@ import { Request, Response } from 'express';
 export declare const listMetrics: (req: Request, res: Response) => Promise<void>;
 export declare const findMetrics: (req: Request, res: Response) => void;
 export declare const resetMetrics: (req: Request, res: Response) => void;
+export declare const insertMetricsToDb: (req: Request, res: Response) => Promise<void>;
+export declare const startMetrics: (req: Request, res: Response) => void;
+export declare const stopMetrics: (req: Request, res: Response) => void;
+export declare const statusMetrics: (req: Request, res: Response) => void;

package/dist/types/tlm-trace/traceController.d.ts

@@ -5,3 +5,4 @@ export declare const statusTelemetry: (req: Request, res: Response) => void;
 export declare const resetTelemetry: (req: Request, res: Response) => void;
 export declare const listTelemetry: (req: Request, res: Response) => Promise<void>;
 export declare const findTelemetry: (req: Request, res: Response) => void;
+export declare const insertTracesToDb: (req: Request, res: Response) => Promise<void>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oas-tools/oas-telemetry",
-  "version": "0.7.0-alpha.0",
+  "version": "0.7.0-alpha.2",
   "description": "Automatically collects and stores telemetry data in memory using OpenTelemetry. Just import the Express middleware to access it through the built-in REST API or web UI—no extra setup required.",
   "author": "Manuel Otero",
   "contributors": [
@@ -19,6 +19,8 @@
     "lint": "eslint --ext .ts . --fix"
   },
   "files": [
+    ".env.example",
+    "NOTICE",
     "dist"
   ],
   "main": "./dist/cjs/index.cjs",

package/dist/cjs/openTelemetry.cjs

@@ -1,56 +0,0 @@
-"use strict";
-
-var _sdkNode = require("@opentelemetry/sdk-node");
-var _resources = require("@opentelemetry/resources");
-var _instrumentationHttp = require("@opentelemetry/instrumentation-http");
-var _config = require("./config.cjs");
-var _systemMetrics = require("./systemMetrics.cjs");
-var _logger = _interopRequireDefault(require("./utils/logger.cjs"));
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-// import { getNodeAutoInstrumentations } from '@opentelemetry/auto-instrumentations-node';
-
-// Import system metrics functions
-
-// DynamicExporter allows changing to any exporter at runtime;
-const dynamicSpanExporter = _config.globalOasTlmConfig.dynamicSpanExporter;
-// Alternative 1: Using NodeSDK
-const sdk = new _sdkNode.NodeSDK({
-  resource: new _resources.Resource({
-    service: 'oas-telemetry-service'
-  }),
-  traceExporter: dynamicSpanExporter,
-  instrumentations: [new _instrumentationHttp.HttpInstrumentation()]
-});
-// Collect and export system metrics
-setInterval(() => {
-  const cpuUsageData = (0, _systemMetrics.getCpuUsageData)();
-  const processCpuUsageData = (0, _systemMetrics.getProcessCpuUsageData)();
-  const memoryData = (0, _systemMetrics.getMemoryData)();
-  const processMemoryData = (0, _systemMetrics.getProcessMemoryData)();
-  const metrics = {
-    timestamp: Date.now(),
-    cpuUsageData,
-    processCpuUsageData,
-    memoryData,
-    processMemoryData
-  };
-  // Export the collected metrics using the InMemoryDBMetricsExporter
-  const inMemoryDbMetricExporter = _config.globalOasTlmConfig.metricsExporter;
-  inMemoryDbMetricExporter.export(metrics, () => {});
-}, _config.globalOasTlmConfig.systemMetricsInterval);
-_logger.default.info('✅ OpenTelemetry System Metrics initialized.');
-if (process.env.OASTLM_MODULE_DISABLED !== 'true') {
-  sdk.start();
-}
-// Alternative 2:
-// const provider = new NodeTracerProvider();
-// provider.addSpanProcessor(new SimpleSpanProcessor(traceExporter));
-// if (process.env.OASTLM_MODULE_DISABLED !== 'true') {
-//   provider.register();
-//   registerInstrumentations({
-//     instrumentations: [
-//       new HttpInstrumentation(),
-//       new ExpressInstrumentation(),
-//     ],
-//   });
-// }

package/dist/cjs/systemMetrics.cjs

@@ -1,97 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.getCpuUsageData = getCpuUsageData;
-exports.getMemoryData = getMemoryData;
-exports.getProcessCpuUsageData = getProcessCpuUsageData;
-exports.getProcessMemoryData = getProcessMemoryData;
-var _os = require("os");
-const MILLISECOND = 1 / 1e3;
-const MICROSECOND = 1 / 1e6;
-let prevOsData = {
-  time: Date.now(),
-  cpus: (0, _os.cpus)()
-};
-function getCpuUsageData() {
-  const currentTime = Date.now();
-  const timeElapsed = currentTime - prevOsData.time;
-  const currentOsData = {
-    time: currentTime,
-    cpus: (0, _os.cpus)()
-  };
-  const usageData = currentOsData.cpus.map((cpu, cpuNumber) => {
-    const prevTimes = prevOsData.cpus[cpuNumber].times;
-    const currTimes = cpu.times;
-    const idle = currTimes.idle * MILLISECOND;
-    const user = currTimes.user * MILLISECOND;
-    const system = currTimes.sys * MILLISECOND;
-    const interrupt = currTimes.irq * MILLISECOND;
-    const nice = currTimes.nice * MILLISECOND;
-    const idleP = (currTimes.idle - prevTimes.idle) / timeElapsed;
-    const userP = (currTimes.user - prevTimes.user) / timeElapsed;
-    const systemP = (currTimes.sys - prevTimes.sys) / timeElapsed;
-    const interruptP = (currTimes.irq - prevTimes.irq) / timeElapsed;
-    const niceP = (currTimes.nice - prevTimes.nice) / timeElapsed;
-    return {
-      cpuNumber: String(cpuNumber),
-      idle,
-      user,
-      system,
-      interrupt,
-      nice,
-      userP,
-      systemP,
-      idleP,
-      interruptP,
-      niceP
-    };
-  });
-  prevOsData = currentOsData;
-  return usageData;
-}
-let prevProcData = {
-  time: Date.now(),
-  usage: process.cpuUsage()
-};
-function getProcessCpuUsageData() {
-  const currentTime = Date.now();
-  const currentUsage = process.cpuUsage();
-  const prevUsage = prevProcData.usage;
-  const timeElapsed = (currentTime - prevProcData.time) * 1000;
-  const cpusTimeElapsed = timeElapsed * prevOsData.cpus.length;
-  const user = currentUsage.user * MICROSECOND;
-  const system = currentUsage.system * MICROSECOND;
-  const userP = (currentUsage.user - prevUsage.user) / cpusTimeElapsed;
-  const systemP = (currentUsage.system - prevUsage.system) / cpusTimeElapsed;
-  prevProcData = {
-    time: currentTime,
-    usage: currentUsage
-  };
-  return {
-    user,
-    system,
-    userP,
-    systemP
-  };
-}
-function getMemoryData() {
-  const total = (0, _os.totalmem)();
-  const free = (0, _os.freemem)();
-  const used = total - free;
-  const freeP = free / total;
-  const usedP = used / total;
-  return {
-    used,
-    free,
-    usedP,
-    freeP
-  };
-}
-function getProcessMemoryData() {
-  if (process.memoryUsage().rss) {
-    return process.memoryUsage().rss;
-  }
-  return 0;
-}