@oas-tools/oas-telemetry 0.5.1 → 0.6.0

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;
@@ -25,6 +26,7 @@ if (process.env.OTDEBUG == "true") dbglog = console.log;
  * @param {Object} [OasTlmConfig.spec] The OpenAPI spec object.
  * @param {string} [OasTlmConfig.specFileName] Alternative to `spec`: the path to the OpenAPI spec file.
  * @param {boolean} [OasTlmConfig.autoActivate=true] Whether to start telemetry automatically on load.
+ * @param {boolean} [OasTlmConfig.authEnabled=true] Whether to enable authentication middleware.
  * @param {number} [OasTlmConfig.apiKeyMaxAge=1800000] The maximum age of the API key in milliseconds.
  * @param {string} [OasTlmConfig.defaultApiKey] The default API key to use.
  * @param {OasTlmExporter} [OasTlmConfig.exporter=InMemoryExporter] The exporter to use. Must implement the `OasTlmExporter` interface.
@@ -50,12 +52,12 @@ function oasTelemetry(OasTlmConfig) {
       console.error("No spec available !");
     }
   }
-  router.use((0, _cookieParser.default)());
+  let allAuthMiddlewares = getWrappedMiddlewares(() => _config.globalOasTlmConfig.authEnabled, [(0, _cookieParser.default)(), _authRoutes.default, _authMiddleware.authMiddleware]);
   const baseURL = _config.globalOasTlmConfig.baseURL;
   router.use((0, _express.json)());
-  router.use(baseURL, _authRoutes.default);
-  router.use(baseURL, _authMiddleware.authMiddleware); // Add the auth middleware
+  router.use(baseURL, allAuthMiddlewares);
   router.use(baseURL, _telemetryRoutes.telemetryRoutes);
+  router.use(baseURL + "/metrics", _metricsRoutes.default);
   if (_config.globalOasTlmConfig.autoActivate) {
     _config.globalOasTlmConfig.dynamicExporter.exporter?.start();
   }
@@ -77,4 +79,32 @@ function oasTelemetry(OasTlmConfig) {
  * @method {Promise<void>} forceFlush() Exports any pending data that has not yet been processed.
  * @property {Array} plugins An array of plugins that can be activated by the exporter.
  */
+
+/**
+ * This function wraps the provided middleware functions with a condition callback.
+ * If the condition callback returns true, the middleware/router will be executed.
+ * If the condition callback returns false, the middleware/router will be skipped.
+ * 
+ * @callback {function} conditionCallback A callback function that returns a boolean to determine if the middleware should be used.
+ * @param {Array} middlewares An array of middleware or routers to be wrapped.
+ * @returns {Array} An array of wrapped middleware functions.
+ */
+function getWrappedMiddlewares(conditionCallback, middlewares) {
+  return middlewares.map(middleware => {
+    return function (req, res, next) {
+      if (conditionCallback()) {
+        if (typeof middleware === 'function') {
+          // look for handle property, if it exists, it's a router. If not call middleware
+          if (middleware.handle) {
+            middleware.handle(req, res, next);
+          } else {
+            middleware(req, res, next);
+          }
+        }
+      } else {
+        next();
+      }
+    };
+  });
+}
 module.exports = exports.default;

package/dist/openTelemetry.cjs

@@ -4,10 +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
 const sdk = new _sdkNode.NodeSDK({
   resource: new _resources.Resource({
     service: 'oas-telemetry-service'
@@ -15,6 +19,40 @@ 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();
-}
+}
+
+// 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/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.1",
+  "version": "0.6.0",
   "description": "This package exports an Express middleware that traces requests and responses of an Express application using OpenTelemetry.",
   "author": "Manuel Otero",
   "contributors": [
@@ -19,6 +19,7 @@
     "testPerformance": "npm i && cd test/performance/ && ./test.sh",
     "pretest": "npm run build",
     "test": "npm run testCJS && npm run testMJS",
+    "build:dockerTest": "npm run build && docker build -t oastlm-test-ks-api -f ./test/performance/ks-api/Dockerfile .",
     "testCJS": "npm run preTestCJS && npm run launchTestCJS && npm run postTestCJS",
     "preTestCJS": "node test/functional/otTestServer.cjs &",
     "launchTestCJS": "npx -y wait-on http://localhost:3000/api/v1/pets && npm run sendRequests && sleep 4 && npm run checkRequestsLog",
@@ -44,9 +45,11 @@
     "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",
+    "@seald-io/nedb": "^4.0.4",
     "axios": "^1.6.8",
     "cookie-parser": "^1.4.7",
     "dynamic-installer": "^1.1.1",
@@ -55,7 +58,6 @@
     "import-from-string": "^0.0.4",
     "js-yaml": "^4.1.0",
     "jsonwebtoken": "^9.0.2",
-    "nedb": "^1.8.0",
     "readline": "^1.3.0",
     "v8": "^0.1.0"
   },

package/src/config.js

@@ -1,14 +1,19 @@
+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: "",
     autoActivate: true,
+    authEnabled: false,
     apiKeyMaxAge: 1000 * 60 * 60, // 1 hour
     password: "oas-telemetry-password",
     jwtSecret: "oas-telemetry-secret",

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/controllers/telemetryController.js

@@ -55,6 +55,7 @@ export const findTelemetry = (req, res) => {
             res.status(404).send({ spansCount: 0, spans: [], error: e });
             return;
         }
+    }
         globalOasTlmConfig.dynamicExporter.exporter.find(search,(err, docs) => {
             if (err) {
                 console.error(err);
@@ -64,5 +65,5 @@ export const findTelemetry = (req, res) => {
             const spans = docs;
             res.send({ spansCount: spans.length, spans: spans });
         });
-    }
+    
 }

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/exporters/InMemoryDbExporter.js

@@ -6,7 +6,7 @@ if (process.env.OTDEBUG == "true")
     dbglog = console.log;
 
 //import in memory database
-import dataStore from 'nedb';
+import dataStore from '@seald-io/nedb';
 
 export class InMemoryExporter {
     constructor() {

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 = () => { };
@@ -22,6 +23,7 @@ if (process.env.OTDEBUG == "true")
  * @param {Object} [OasTlmConfig.spec] The OpenAPI spec object.
  * @param {string} [OasTlmConfig.specFileName] Alternative to `spec`: the path to the OpenAPI spec file.
  * @param {boolean} [OasTlmConfig.autoActivate=true] Whether to start telemetry automatically on load.
+ * @param {boolean} [OasTlmConfig.authEnabled=true] Whether to enable authentication middleware.
  * @param {number} [OasTlmConfig.apiKeyMaxAge=1800000] The maximum age of the API key in milliseconds.
  * @param {string} [OasTlmConfig.defaultApiKey] The default API key to use.
  * @param {OasTlmExporter} [OasTlmConfig.exporter=InMemoryExporter] The exporter to use. Must implement the `OasTlmExporter` interface.
@@ -51,13 +53,12 @@ export default function oasTelemetry(OasTlmConfig) {
             console.error("No spec available !");
         }
     }
-
-    router.use(cookieParser());
+    let allAuthMiddlewares = getWrappedMiddlewares(() => globalOasTlmConfig.authEnabled, [cookieParser(),authRoutes,authMiddleware]);
     const baseURL = globalOasTlmConfig.baseURL;
     router.use(json());
-    router.use(baseURL, authRoutes);
-    router.use(baseURL, authMiddleware); // Add the auth middleware
+    router.use(baseURL, allAuthMiddlewares);
     router.use(baseURL, telemetryRoutes);
+    router.use(baseURL + "/metrics", metricsRoutes);
 
     if (globalOasTlmConfig.autoActivate) {
         globalOasTlmConfig.dynamicExporter.exporter?.start();
@@ -67,7 +68,6 @@ export default function oasTelemetry(OasTlmConfig) {
 }
 
 
-
 /**
  * @typedef OasTlmExporter
  * Represents an exporter that processes and manages telemetry data.
@@ -83,3 +83,32 @@ export default function oasTelemetry(OasTlmConfig) {
  * @method {Promise<void>} forceFlush() Exports any pending data that has not yet been processed.
  * @property {Array} plugins An array of plugins that can be activated by the exporter.
  */
+
+/**
+ * This function wraps the provided middleware functions with a condition callback.
+ * If the condition callback returns true, the middleware/router will be executed.
+ * If the condition callback returns false, the middleware/router will be skipped.
+ * 
+ * @callback {function} conditionCallback A callback function that returns a boolean to determine if the middleware should be used.
+ * @param {Array} middlewares An array of middleware or routers to be wrapped.
+ * @returns {Array} An array of wrapped middleware functions.
+ */
+function getWrappedMiddlewares(conditionCallback, middlewares) {
+    return middlewares.map(middleware => {
+        return function (req, res, next) {
+            if (conditionCallback()) {
+                if (typeof middleware === 'function') {
+                    // look for handle property, if it exists, it's a router. If not call middleware
+                    if (middleware.handle) {
+                        middleware.handle(req, res, next);
+                    } else {
+                        middleware(req, res, next);
+                    }
+                }
+            } else {
+                next();
+            }
+        };
+    }
+    );
+}

package/src/openTelemetry.js

@@ -1,22 +1,58 @@
-
 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;
+if (process.env.OASTLM_MODULE_DISABLED !== 'true') {
+  sdk.start()
+}
 
-  const sdk = new NodeSDK({
-    resource: new Resource({
-      service: 'oas-telemetry-service'
-    }),
-    traceExporter,
-    instrumentations: [new HttpInstrumentation()]
-  });
+// Alternative 2:
+// const provider = new NodeTracerProvider();
+// provider.addSpanProcessor(new SimpleSpanProcessor(traceExporter));
 
-  if (process.env.OASTLM_MODULE_DISABLED !== 'true') {
-    sdk.start()
-  }
+// if (process.env.OASTLM_MODULE_DISABLED !== 'true') {
+//   provider.register();
+//   registerInstrumentations({
+//     instrumentations: [
+//       new HttpInstrumentation(),
+//       new ExpressInstrumentation(),
+//     ],
+//   });
+// }

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/services/uiService.js

@@ -1,17 +1,17 @@
-
-
-// WARNING: This file is autogenerated. DO NOT EDIT!
-//This file is autogenerated by dev/ui/exportHtmlToUi.js
-const ui = (baseURL) => {
-    if(!baseURL) return htmlMap;
-    return Object.keys(htmlMap).reduce((acc, key) => {
-        acc[key] = htmlMap[key].replace(/\/telemetry/g, baseURL);
-        return acc;
-    }, {});
-}
-
-export const htmlMap = 
-    {
+
+
+// WARNING: This file is autogenerated. DO NOT EDIT!
+//This file is autogenerated by dev/ui/exportHtmlToUi.js
+const ui = (baseURL) => {
+    if(!baseURL) return htmlMap;
+    return Object.keys(htmlMap).reduce((acc, key) => {
+        acc[key] = htmlMap[key].replace(/\/telemetry/g, baseURL);
+        return acc;
+    }, {});
+}
+
+export const htmlMap = 
+    {
 detail: `<!DOCTYPE html>
 <html lang="en">
 
@@ -632,7 +632,7 @@ detail: `<!DOCTYPE html>
 
 </body>
 
-</html>`,
+</html>`,
 login: `<!DOCTYPE html>
 <html lang="en">
 <head>
@@ -813,7 +813,7 @@ login: `<!DOCTYPE html>
     </script>
 </body>
 </html>
-`,
+`,
 main: `<!DOCTYPE html>
 <html lang="en">
 
@@ -1513,8 +1513,8 @@ main: `<!DOCTYPE html>
     </script>
 </body>
 
-</html>`,
-};
-
-    
-export default ui
+</html>`,
+};
+
+    
+export default ui