@oas-tools/oas-telemetry 0.5.2 → 0.6.1

package/README.md

@@ -10,25 +10,22 @@ Overall, **OAS Telemetry** will serve as a valuable tool for developers looking
 
 The package now supports both **ES Module (ESM)** and **CommonJS (CJS)** formats, making it compatible with a wide range of applications. Furthermore, **OAS Telemetry** provides a range of plugins to extend its functionality, enabling developers to tailor telemetry data collection, alerting, and reporting to meet specific requirements. See the [Telemetry Plugins](#telemetry-plugins) section for more information.
 
-
-
-
 ## Usage
 
 This section provides an overview of how to install and integrate **OAS Telemetry** into your EXISTING **Express.js** application. If you want to create a new example express application with **OAS Telemetry** integrated, refer to the [Full Examples](#full-examples) section at the end of this document.
 
-
 First, install the package using npm:
+
 ```sh
 npm install @oas-tools/oas-telemetry
 ```
 
-
 You can integrate the middleware into your Express application. The `spec` option is the OpenAPI Specification (OAS) content in JSON or YAML format. While this configuration is optional, it is recommended for the UI to function correctly.
 
 ### Using ES Modules (ESM)
 
 Add the following lines to your `index.js` file:
+
 ```js
 // This import MUST be at the top of the file
 import oasTelemetry from '@oas-tools/oas-telemetry';
@@ -44,6 +41,7 @@ app.use(oasTelemetry({
 ### Using CommonJS
 
 Add the following lines to your `index.js` file:
+
 ```js
 // This require MUST be at the top of the file
 const oasTelemetry = require('@oas-tools/oas-telemetry');
@@ -61,6 +59,7 @@ For complete examples of a working API with OAS Telemetry enabled, refer to the
 ## Custom Configuration
 
 You can also customize the telemetry configuration by passing options to the middleware function. For example:
+
 ```js
 const customTelemetryConfig = {
     spec: /* OAS content in json or yaml */, // Highly recommended
@@ -82,6 +81,52 @@ app.use(oasTelemetry(customTelemetryConfig));
 
 You can access the telemetry UI in the endpoint `/telemetry` (or `/custom-telemetry` if you set the `baseURL` option). This UI provides a user-friendly interface to interact with the telemetry data collected by the middleware.
 
+## Metrics Development (Temporary)
+
+This feature is currently in development. The following endpoints are available under <baseURL>/metrics (e.g., /telemetry/metrics):
+
+- GET /
+- POST /find
+- GET /reset
+
+Expect an array of metrics objects. Each object includes data like a timestamp, cpuUsageData, processCpuUsageData, memoryData, and processMemoryData. Example snippet for one CPU core (followed by others in the array):
+
+```json
+{
+    "timestamp": 1741717005911,
+    "cpuUsageData": [
+        {
+            "cpuNumber": "0",
+            "idle": 60486.234000000004,
+            "user": 1364.515,
+            "system": 1246.796,
+            "interrupt": 167,
+            "nice": 0,
+            "userP": 0.009375623379214043,
+            "systemP": 0.002992220227408737,
+            "idleP": 0.9850388988629563,
+            "interruptP": 0,
+            "niceP": 0
+        }
+    ],
+    "processCpuUsageData": {
+        "user": 0.968,
+        "system": 0.32799999999999996,
+        "userP": 0,
+        "systemP": 0
+    },
+    "memoryData": {
+        "used": 15726522368,
+        "free": 18437427200,
+        "usedP": 0.4603250668280579,
+        "freeP": 0.539674933171942
+    },
+    "processMemoryData": 75988992,
+    "_id": "6mXKM8uK7xSOqJVT"
+}
+```
+
+The shape of these objects may change as development continues.
 
 ## API Telemetry Endpoints
 
@@ -104,12 +149,12 @@ OAS Telemetry supports a range of plugins to extend its functionality, allowing
 One example plugin is the **Outlier Alert Over Messaging** plugin, which can be configured to send anomaly alerts to messaging platforms like Telegram. This plugin is especially useful for monitoring abnormal response times in your API, notifying selected channels to allow rapid responses to potential issues. For setup details, refer to its [README documentation](https://github.com/oas-tools/oas-telemetry-plugin-outlier-messaging/blob/main/README.md).
 
 OAS Telemetry plugins are flexible and support both ES Modules (ESM) and CommonJS (CJS) formats, regardless of whether your application is using ESM or CJS. This compatibility ensures that plugins work seamlessly in all configurations:
+
 - ESM applications can use plugins in either ESM or CJS format.
 - CJS applications can use plugins in either CJS or ESM format.
 
 This flexibility makes it easy to incorporate a wide variety of plugins in your preferred module system.
 
-
 ## Accessing Telemetry Data
 
 Using OAS Telemetry, you can access telemetry data through the UI, the `/telemetry/list` endpoint, or the `/telemetry/find` endpoint with a POST request using a MongoDB search syntax.
@@ -117,7 +162,9 @@ Using OAS Telemetry, you can access telemetry data through the UI, the `/telemet
 Note: if authentication is enabled, you must provide the correct credentials to access the telemetry data.
 
 ### Simple Search Example
+
 To perform a simple search, send a POST request to the `/telemetry/find` endpoint with the following JSON payload:
+
 ```json
 {
     "search": {
@@ -132,7 +179,9 @@ To perform a simple search, send a POST request to the `/telemetry/find` endpoin
 ```
 
 ### Complex Search Example
+
 For more complex searches using regex, additional parsing on the server and extra attributes in the POST request are required. Send a POST request to the `/telemetry/find` endpoint with the following JSON payload:
+
 ```json
 {
     "flags": {
@@ -153,19 +202,25 @@ For more complex searches using regex, additional parsing on the server and extr
 ```
 
 ## Full Examples
+
 To run these examples, follow these steps:
 
 1. Create a new folder for your project.
 2. Navigate to the folder and initialize a new Node.js project:
+
     ```sh
     npm init -y
     ```
+
 3. Install the **OAS Telemetry** package:
+
     ```sh
     npm install @oas-tools/oas-telemetry
     ```
+
 4. Save the example code as `index.js` in the project folder.
 5. Run the application:
+
     ```sh
     node index.js
     ```
@@ -173,6 +228,7 @@ To run these examples, follow these steps:
 Your project folder should now contain the necessary files to run the example with **OAS Telemetry** integrated.
 
 ### Simple Example [ES Module](https://nodejs.org/docs/latest/api/esm.html) (*.mjs)
+
 ```js index.mjs
 import oasTelemetry from '@oas-tools/oas-telemetry';
 import express from 'express';
@@ -280,6 +336,7 @@ app.get("/api/v1/clinics", (req, res) => {
 ```
 
 ### Simple Example [Common.js Module](https://nodejs.org/docs/latest/api/modules.html) (*.cjs)
+
 ```js index.cjs
 let oasTelemetry = require('@oas-tools/oas-telemetry');
 let express = require('express');
@@ -383,5 +440,3 @@ app.get("/api/v1/clinics", (req, res) => {
     res.send(clinics);
 });
 ```
-
-

package/dist/config.cjs

@@ -4,13 +4,18 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.globalOasTlmConfig = exports.default = void 0;
+var _api = require("@opentelemetry/api");
 var _dynamicExporter = _interopRequireDefault(require("./exporters/dynamicExporter.cjs"));
+var _InMemoryDBMetricsExporter = require("./exporters/InMemoryDBMetricsExporter.cjs");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 //Environment variables
 //OASTLM_MODULE_DISABLED = 'true' //Disables the module (empty middleware and no tracing)
 
 const globalOasTlmConfig = exports.globalOasTlmConfig = {
   dynamicExporter: new _dynamicExporter.default(),
+  metricsExporter: new _InMemoryDBMetricsExporter.InMemoryDBMetricsExporter(),
+  systemMetricsInterval: 1000 * 5,
+  // 5 seconds
   baseURL: "/telemetry",
   spec: null,
   specFileName: "",

package/dist/controllers/metricsController.cjs

@@ -0,0 +1,48 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.resetMetrics = exports.listMetrics = exports.findMetrics = void 0;
+var _config = require("../config.cjs");
+const listMetrics = async (req, res) => {
+  try {
+    const metrics = await _config.globalOasTlmConfig.metricsExporter.getFinishedMetrics();
+    res.send({
+      metricsCount: metrics.length,
+      metrics: metrics
+    });
+  } catch (err) {
+    console.error(err);
+    res.status(500).send({
+      error: 'Failed to list metrics data'
+    });
+  }
+};
+exports.listMetrics = listMetrics;
+const findMetrics = (req, res) => {
+  const body = req.body;
+  const search = body?.search ? body.search : {};
+  _config.globalOasTlmConfig.metricsExporter.find(search, (err, docs) => {
+    if (err) {
+      console.error(err);
+      res.status(404).send({
+        metricsCount: 0,
+        metrics: [],
+        error: err
+      });
+      return;
+    }
+    const metrics = docs;
+    res.send({
+      metricsCount: metrics.length,
+      metrics: metrics
+    });
+  });
+};
+exports.findMetrics = findMetrics;
+const resetMetrics = (req, res) => {
+  _config.globalOasTlmConfig.metricsExporter.reset();
+  res.send('Metrics reset');
+};
+exports.resetMetrics = resetMetrics;

package/dist/exporters/InMemoryDBMetricsExporter.cjs

@@ -0,0 +1,101 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.InMemoryDBMetricsExporter = void 0;
+var _core = require("@opentelemetry/core");
+var _nedb = _interopRequireDefault(require("@seald-io/nedb"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+class InMemoryDBMetricsExporter {
+  constructor() {
+    this._metrics = new _nedb.default();
+    this._stopped = false;
+  }
+  export(metrics, resultCallback) {
+    try {
+      if (!this._stopped) {
+        // metrics = metrics?.scopeMetrics;
+        // const cleanMetrics = metrics.map(metric => applyNesting(metric));
+        this._metrics.insert(metrics, (err, newDoc) => {
+          if (err) {
+            console.error('Insertion Error:', err);
+            return;
+          }
+        });
+      }
+      setTimeout(() => resultCallback({
+        code: _core.ExportResultCode.SUCCESS
+      }), 0);
+    } catch (error) {
+      console.error('Error exporting metrics\n' + error.message + '\n' + error.stack);
+      return resultCallback({
+        code: _core.ExportResultCode.FAILED,
+        error: new Error('Error exporting metrics\n' + error.message + '\n' + error.stack)
+      });
+    }
+  }
+  start() {
+    this._stopped = false;
+  }
+  stop() {
+    this._stopped = true;
+  }
+  isRunning() {
+    return !this._stopped;
+  }
+  shutdown() {
+    this._stopped = true;
+    this._metrics = new _nedb.default();
+    return this.forceFlush();
+  }
+  forceFlush() {
+    return Promise.resolve();
+  }
+  find(search, callback) {
+    this._metrics.find(search, callback);
+  }
+  reset() {
+    this._metrics = new _nedb.default();
+  }
+  getFinishedMetrics() {
+    return this._metrics.getAllData();
+  }
+}
+exports.InMemoryDBMetricsExporter = InMemoryDBMetricsExporter;
+function convertToNestedObject(obj) {
+  const result = {};
+  for (const key in obj) {
+    const keys = key.split('.');
+    let temp = result;
+    for (let i = 0; i < keys.length; i++) {
+      const currentKey = keys[i];
+      if (i === keys.length - 1) {
+        // Last key, set the value
+        temp[currentKey] = obj[key];
+      } else {
+        // Intermediate key, ensure the object exists
+        if (!temp[currentKey]) {
+          temp[currentKey] = {};
+        }
+        temp = temp[currentKey];
+      }
+    }
+  }
+  return result;
+}
+
+/**
+ * Applies nesting to all dot-separated keys within an object.
+ * 
+ * @param {Object} obj - The object to apply nesting to.
+ * @returns {Object} - The transformed object with nested structures.
+ */
+function applyNesting(obj) {
+  for (const key in obj) {
+    if (typeof obj[key] === 'object' && obj[key] !== null) {
+      obj[key] = applyNesting(obj[key]);
+    }
+  }
+  return obj;
+}

package/dist/index.cjs

@@ -12,6 +12,7 @@ var _authMiddleware = require("./middleware/authMiddleware.cjs");
 var _authRoutes = _interopRequireDefault(require("./routes/authRoutes.cjs"));
 var _telemetryRoutes = require("./routes/telemetryRoutes.cjs");
 var _InMemoryDbExporter = require("./exporters/InMemoryDbExporter.cjs");
+var _metricsRoutes = _interopRequireDefault(require("./routes/metricsRoutes.cjs"));
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 let dbglog = () => {};
 if (process.env.OTDEBUG == "true") dbglog = console.log;
@@ -56,6 +57,7 @@ function oasTelemetry(OasTlmConfig) {
   router.use((0, _express.json)());
   router.use(baseURL, allAuthMiddlewares);
   router.use(baseURL, _telemetryRoutes.telemetryRoutes);
+  router.use(baseURL + "/metrics", _metricsRoutes.default);
   if (_config.globalOasTlmConfig.autoActivate) {
     _config.globalOasTlmConfig.dynamicExporter.exporter?.start();
   }

package/dist/openTelemetry.cjs

@@ -4,11 +4,14 @@ 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");
 // import { getNodeAutoInstrumentations } from '@opentelemetry/auto-instrumentations-node';
 
+// Import system metrics functions
+
 // DynamicExporter allows changing to any exporter at runtime;
 const traceExporter = _config.globalOasTlmConfig.dynamicExporter;
-//  Alternative 1: Using NodeSDK
+// Alternative 1: Using NodeSDK
 const sdk = new _sdkNode.NodeSDK({
   resource: new _resources.Resource({
     service: 'oas-telemetry-service'
@@ -16,6 +19,26 @@ const sdk = new _sdkNode.NodeSDK({
   traceExporter,
   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, result => {});
+}, _config.globalOasTlmConfig.systemMetricsInterval);
+console.log('✅ OpenTelemetry System Metrics initialized.');
 if (process.env.OASTLM_MODULE_DISABLED !== 'true') {
   sdk.start();
 }

package/dist/routes/metricsRoutes.cjs

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.metricsRoutes = exports.default = void 0;
+var _express = require("express");
+var _metricsController = require("../controllers/metricsController.cjs");
+const metricsRoutes = exports.metricsRoutes = (0, _express.Router)();
+
+// Metrics Control
+metricsRoutes.get('/', _metricsController.listMetrics);
+metricsRoutes.post('/find', _metricsController.findMetrics);
+metricsRoutes.get('/reset', _metricsController.resetMetrics);
+var _default = exports.default = metricsRoutes;

package/dist/systemMetrics.cjs

@@ -0,0 +1,97 @@
+"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: used,
+    free: free,
+    usedP: usedP,
+    freeP: freeP
+  };
+}
+function getProcessMemoryData() {
+  if (process.memoryUsage.rss) {
+    return process.memoryUsage.rss();
+  }
+  return process.memoryUsage().rss;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oas-tools/oas-telemetry",
-  "version": "0.5.2",
+  "version": "0.6.1",
   "description": "This package exports an Express middleware that traces requests and responses of an Express application using OpenTelemetry.",
   "author": "Manuel Otero",
   "contributors": [
@@ -45,6 +45,7 @@
     "default": "./src/index.js"
   },
   "dependencies": {
+    "@opentelemetry/host-metrics": "^0.35.5",
     "@opentelemetry/instrumentation-http": "^0.51.0",
     "@opentelemetry/resources": "^1.24.0",
     "@opentelemetry/sdk-node": "^0.49.1",

package/src/config.js

@@ -1,10 +1,14 @@
+import { metrics } from "@opentelemetry/api";
 import DynamicExporter from "./exporters/dynamicExporter.js";
+import { InMemoryDBMetricsExporter } from "./exporters/InMemoryDBMetricsExporter.js";
 
 //Environment variables
 //OASTLM_MODULE_DISABLED = 'true' //Disables the module (empty middleware and no tracing)
 
 export const globalOasTlmConfig = {
     dynamicExporter: new DynamicExporter(),
+    metricsExporter: new InMemoryDBMetricsExporter(),
+    systemMetricsInterval: 1000 * 5, // 5 seconds
     baseURL: "/telemetry",
     spec: null,
     specFileName: "",

package/src/controllers/metricsController.js

@@ -0,0 +1,30 @@
+import { globalOasTlmConfig } from '../config.js';
+
+export const listMetrics = async (req, res) => {
+    try {
+        const metrics = await globalOasTlmConfig.metricsExporter.getFinishedMetrics();
+        res.send({ metricsCount: metrics.length, metrics: metrics });
+    } catch (err) {
+        console.error(err);
+        res.status(500).send({ error: 'Failed to list metrics data' });
+    }
+}
+
+export const findMetrics = (req, res) => {
+    const body = req.body;
+    const search = body?.search ? body.search : {};
+    globalOasTlmConfig.metricsExporter.find(search, (err, docs) => {
+        if (err) {
+            console.error(err);
+            res.status(404).send({ metricsCount: 0, metrics: [], error: err });
+            return;
+        }
+        const metrics = docs;
+        res.send({ metricsCount: metrics.length, metrics: metrics });
+    });
+}
+
+export const resetMetrics = (req, res) => {
+    globalOasTlmConfig.metricsExporter.reset();
+    res.send('Metrics reset');
+}

package/src/exporters/InMemoryDBMetricsExporter.js

@@ -0,0 +1,111 @@
+import { ExportResultCode } from '@opentelemetry/core';
+import dataStore from '@seald-io/nedb';
+
+export class InMemoryDBMetricsExporter {
+    constructor() {
+        this._metrics = new dataStore();
+        this._stopped = false;
+    }
+
+    export(metrics, resultCallback) {
+        try {
+            if (!this._stopped) {
+                // metrics = metrics?.scopeMetrics;
+                // const cleanMetrics = metrics.map(metric => applyNesting(metric));
+                this._metrics.insert(metrics, (err, newDoc) => {
+                    if (err) {
+                        console.error('Insertion Error:', err); 
+                        return;
+                    }
+                });
+            }
+            setTimeout(() => resultCallback({ code: ExportResultCode.SUCCESS }), 0);
+        } catch (error) {
+            console.error('Error exporting metrics\n' + error.message + '\n' + error.stack);
+            return resultCallback({
+                code: ExportResultCode.FAILED,
+                error: new Error('Error exporting metrics\n' + error.message + '\n' + error.stack),
+            });
+        }
+    }
+
+    start() {
+        this._stopped = false;
+    }
+
+    stop() {
+        this._stopped = true;
+    }
+
+    isRunning() {
+        return !this._stopped;
+    }
+
+    shutdown() {
+        this._stopped = true;
+        this._metrics = new dataStore();
+        return this.forceFlush();
+    }
+
+    forceFlush() {
+        return Promise.resolve();
+    }
+
+    find(search, callback) {
+        this._metrics.find(search, callback);
+    }
+
+    reset() {
+        this._metrics = new dataStore();
+    }
+
+    getFinishedMetrics() {
+        return this._metrics.getAllData();
+    }
+}
+
+function convertToNestedObject(obj) {
+    const result = {};
+
+    for (const key in obj) {
+        const keys = key.split('.');
+        let temp = result;
+
+        for (let i = 0; i < keys.length; i++) {
+            const currentKey = keys[i];
+
+            if (i === keys.length - 1) {
+                // Last key, set the value
+                temp[currentKey] = obj[key];
+            } else {
+                // Intermediate key, ensure the object exists
+                if (!temp[currentKey]) {
+                    temp[currentKey] = {};
+                }
+                temp = temp[currentKey];
+            }
+        }
+    }
+
+    return result;
+}
+
+/**
+ * Applies nesting to all dot-separated keys within an object.
+ * 
+ * @param {Object} obj - The object to apply nesting to.
+ * @returns {Object} - The transformed object with nested structures.
+ */
+function applyNesting(obj) {
+
+
+        for (const key in obj) {
+            if (typeof obj[key] === 'object' && obj[key] !== null) {
+                obj[key] = applyNesting(obj[key]);
+            }
+        }
+
+
+    return obj;
+}
+

package/src/index.js

@@ -6,6 +6,7 @@ import { authMiddleware } from './middleware/authMiddleware.js';
 import authRoutes from './routes/authRoutes.js';
 import { telemetryRoutes } from './routes/telemetryRoutes.js';
 import { InMemoryExporter } from './exporters/InMemoryDbExporter.js';
+import metricsRoutes from './routes/metricsRoutes.js';
 
 
 let dbglog = () => { };
@@ -41,7 +42,7 @@ export default function oasTelemetry(OasTlmConfig) {
         }
     }
     console.log("baseURL: ", globalOasTlmConfig.baseURL);
-    globalOasTlmConfig.dynamicExporter.changeExporter( OasTlmConfig.exporter ?? new InMemoryExporter() );
+    globalOasTlmConfig.dynamicExporter.changeExporter( globalOasTlmConfig.exporter ?? new InMemoryExporter() );
 
     if (globalOasTlmConfig.spec)
         dbglog(`Spec content provided`);
@@ -57,6 +58,7 @@ export default function oasTelemetry(OasTlmConfig) {
     router.use(json());
     router.use(baseURL, allAuthMiddlewares);
     router.use(baseURL, telemetryRoutes);
+    router.use(baseURL + "/metrics", metricsRoutes);
 
     if (globalOasTlmConfig.autoActivate) {
         globalOasTlmConfig.dynamicExporter.exporter?.start();

package/src/openTelemetry.js

@@ -1,25 +1,47 @@
-
 import { NodeSDK } from '@opentelemetry/sdk-node';
 // import { getNodeAutoInstrumentations } from '@opentelemetry/auto-instrumentations-node';
 import { Resource } from '@opentelemetry/resources';
 import { HttpInstrumentation } from '@opentelemetry/instrumentation-http';
 import { globalOasTlmConfig } from './config.js';
+import { getCpuUsageData, getProcessCpuUsageData, getMemoryData, getProcessMemoryData } from './systemMetrics.js'; // Import system metrics functions
+
+// DynamicExporter allows changing to any exporter at runtime;
+const traceExporter = globalOasTlmConfig.dynamicExporter;
+// Alternative 1: Using NodeSDK
+const sdk = new NodeSDK({
+  resource: new Resource({
+    service: 'oas-telemetry-service'
+  }),
+  traceExporter,
+  instrumentations: [new HttpInstrumentation()]
+});
+
+
+// Collect and export system metrics
+setInterval(() => {
+  const cpuUsageData = getCpuUsageData();
+  const processCpuUsageData = getProcessCpuUsageData();
+  const memoryData = getMemoryData();
+  const processMemoryData = getProcessMemoryData();
+
+  const metrics = {
+    timestamp: Date.now(), 
+    cpuUsageData,
+    processCpuUsageData,
+    memoryData,
+    processMemoryData,
+  };
+
+  // Export the collected metrics using the InMemoryDBMetricsExporter
+  const inMemoryDbMetricExporter = globalOasTlmConfig.metricsExporter;
+  inMemoryDbMetricExporter.export(metrics, (result) => {});
+}, globalOasTlmConfig.systemMetricsInterval);
 
+console.log('✅ OpenTelemetry System Metrics initialized.');
 
-  // DynamicExporter allows changing to any exporter at runtime;
-  const traceExporter = globalOasTlmConfig.dynamicExporter;
-//  Alternative 1: Using NodeSDK
-  const sdk = new NodeSDK({
-    resource: new Resource({
-      service: 'oas-telemetry-service'
-    }),
-    traceExporter,
-    instrumentations: [new HttpInstrumentation()]
-  });
-
-  if (process.env.OASTLM_MODULE_DISABLED !== 'true') {
-    sdk.start()
-  }
+if (process.env.OASTLM_MODULE_DISABLED !== 'true') {
+  sdk.start()
+}
 
 // Alternative 2:
 // const provider = new NodeTracerProvider();

package/src/routes/metricsRoutes.js

@@ -0,0 +1,15 @@
+import { Router } from 'express';
+import {
+    listMetrics,
+    findMetrics,
+    resetMetrics
+} from '../controllers/metricsController.js';
+
+export const metricsRoutes = Router();
+
+// Metrics Control
+metricsRoutes.get('/', listMetrics);
+metricsRoutes.post('/find', findMetrics);
+metricsRoutes.get('/reset', resetMetrics);
+
+export default metricsRoutes;

package/src/systemMetrics.js

@@ -0,0 +1,102 @@
+import { cpus, totalmem, freemem } from 'os';
+
+const MILLISECOND = 1 / 1e3;
+const MICROSECOND = 1 / 1e6;
+
+let prevOsData = {
+  time: Date.now(),
+  cpus: cpus(),
+};
+
+export function getCpuUsageData() {
+  const currentTime = Date.now();
+  const timeElapsed = currentTime - prevOsData.time;
+  const currentOsData = { time: currentTime, cpus: 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(),
+};
+
+
+
+
+export 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,
+  };
+}
+
+export function getMemoryData() {
+  const total = totalmem();
+  const free = freemem();
+  const used = total - free;
+  const freeP = free / total;
+  const usedP = used / total;
+
+  return {
+    used: used,
+    free: free,
+    usedP: usedP,
+    freeP: freeP,
+  };
+}
+
+export function getProcessMemoryData() {
+  if (process.memoryUsage.rss) {
+    return process.memoryUsage.rss();
+  }
+  return process.memoryUsage().rss;
+}