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

package/dist/esm/tlm-auth/authMiddleware.js

@@ -1,12 +1,13 @@
-import { globalOasTlmConfig } from "../config.js";
 import jwt from 'jsonwebtoken';
-export function authMiddleware(req, res, next) {
-    const apiKey = req.cookies.apiKey;
-    if (apiKey) {
-        const decoded = jwt.verify(apiKey, globalOasTlmConfig.jwtSecret);
-        if (decoded.password === globalOasTlmConfig.password) {
-            return next();
+export function getAuthMiddleware(oasTlmConfig) {
+    return function authMiddleware(req, res, next) {
+        const apiKey = req.cookies.apiKey;
+        if (apiKey) {
+            const decoded = jwt.verify(apiKey, oasTlmConfig.auth.jwtSecret);
+            if (decoded.password === oasTlmConfig.auth.password) {
+                return next();
+            }
         }
-    }
-    res.status(401).redirect(globalOasTlmConfig.baseURL + '/login');
+        res.status(401).redirect(oasTlmConfig.general.baseUrl + oasTlmConfig.general.uiPath + '/login');
+    };
 }

package/dist/esm/tlm-auth/authRoutes.js

@@ -1,7 +1,9 @@
 import { Router } from 'express';
-import { login, logout, check } from './authController.js';
-const router = Router();
-router.post('/login', login);
-router.get('/logout', logout);
-router.get('/check', check);
-export default router;
+import { getLogin, getLogout, getCheck } from './authController.js';
+export const getAuthRoutes = (oasTlmConfig) => {
+    const router = Router();
+    router.post('/login', getLogin(oasTlmConfig));
+    router.get('/logout', getLogout(oasTlmConfig));
+    router.get('/check', getCheck(oasTlmConfig));
+    return router;
+};

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

@@ -1,22 +1,33 @@
-import { globalOasTlmConfig } from '../config.js';
+import { inMemoryDbLogExporter } from '../telemetry/telemetryRegistry.js';
+import logger from '../utils/logger.js';
+import { convertRegexRecursively } from '../utils/regexUtils.js';
 export const listLogs = async (req, res) => {
     try {
-        const logs = globalOasTlmConfig.logExporter.getFinishedLogs();
+        const logs = inMemoryDbLogExporter.getFinishedLogs();
         res.send({ logsCount: logs.length, logs: logs });
     }
     catch (err) {
-        console.error(err);
+        logger.error(err);
         res.status(500).send({ error: 'Failed to list log data' });
     }
 };
 export const findLogs = async (req, res) => {
     const body = req.body;
-    const messageSearch = body?.search || null; // Search term for MiniSearch
-    const findQuery = body?.find || {}; // Query for NeDB
-    console.dir(`findLogs called with query: ${JSON.stringify(findQuery)} and search ${messageSearch}`, { depth: 3 });
+    const messageSearch = body?.textSearch || null; // Search term for MiniSearch
+    const findQuery = body?.query || {}; // Query for NeDB
+    logger.debug(`findLogs called with query: ${JSON.stringify(findQuery)} and search ${messageSearch}`, { depth: 3 });
+    let processedQuery;
+    try {
+        processedQuery = convertRegexRecursively(findQuery);
+    }
+    catch (error) {
+        logger.error(error.message);
+        res.status(400).send({ error: error.message });
+        return; // Exit if invalid regex was encountered
+    }
     try {
         const results = await new Promise((resolve, reject) => {
-            globalOasTlmConfig.logExporter.find(findQuery, messageSearch, (err, docs) => {
+            inMemoryDbLogExporter.find(processedQuery, messageSearch, (err, docs) => {
                 if (err)
                     return reject(err);
                 resolve(docs);
@@ -26,12 +37,12 @@ export const findLogs = async (req, res) => {
         res.send({ logsCount: typedResults.length, logs: typedResults });
     }
     catch (err) {
-        console.error(err);
+        logger.error(err);
         res.status(500).send({ error: 'Failed to find logs', details: err.message });
     }
 };
 export const resetLogs = (req, res) => {
-    globalOasTlmConfig.logExporter.reset();
+    inMemoryDbLogExporter.reset();
     res.send('Logs reset');
 };
 export const insertLogsToDb = async (req, res) => {
@@ -49,13 +60,13 @@ export const insertLogsToDb = async (req, res) => {
     try {
         let message = '';
         if (resetData) {
-            globalOasTlmConfig.logExporter.reset();
+            inMemoryDbLogExporter.reset();
             message += 'Logs Database reset. ';
         }
         await new Promise((resolve, reject) => {
-            globalOasTlmConfig.logExporter.insert(cleanedLogs, (err, newDocs) => {
+            inMemoryDbLogExporter.insert(cleanedLogs, (err, newDocs) => {
                 if (err) {
-                    console.error('Error inserting logs:', err);
+                    logger.error('Error inserting logs:', err);
                     return reject(err);
                 }
                 resolve(newDocs);
@@ -65,19 +76,28 @@ export const insertLogsToDb = async (req, res) => {
         res.send({ message, InsertedLogsCount: cleanedLogs.length });
     }
     catch (err) {
-        console.error(err);
+        logger.error(err);
         res.status(500).send({ error: 'Failed to reset and insert data', details: err.message });
     }
 };
 export const startLogs = (req, res) => {
-    globalOasTlmConfig.logExporter.start();
+    inMemoryDbLogExporter.enable();
     res.send('Log collection started');
 };
 export const stopLogs = (req, res) => {
-    globalOasTlmConfig.logExporter.stop();
+    inMemoryDbLogExporter.disable();
     res.send('Log collection stopped');
 };
 export const statusLogs = (req, res) => {
-    const isRunning = globalOasTlmConfig.logExporter.isRunning() || false;
+    const isRunning = inMemoryDbLogExporter.isEnabled() || false;
     res.send({ active: isRunning });
 };
+export const setRetentionTimeLogs = (req, res) => {
+    const retentionTime = req.body.retentionTime;
+    if (typeof retentionTime !== 'number' || retentionTime <= 0) {
+        res.status(400).send({ error: 'Invalid retention time. Must be a positive number.' });
+        return;
+    }
+    inMemoryDbLogExporter.retentionTimeInSeconds = retentionTime;
+    res.send({ message: `Retention time set to ${retentionTime} seconds.` });
+};

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

@@ -1,12 +1,16 @@
 import { Router } from 'express';
-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);
-export default logRoutes;
+import { startLogs, stopLogs, statusLogs, resetLogs, listLogs, findLogs, insertLogsToDb, setRetentionTimeLogs } from './logController.js';
+export const getLogRoutes = () => {
+    const router = Router();
+    // Logs Control
+    router.post('/start', startLogs);
+    router.post('/stop', stopLogs);
+    router.get('/status', statusLogs);
+    router.post('/reset', resetLogs);
+    router.post('/retention-time', setRetentionTimeLogs);
+    router.get('/', listLogs);
+    router.post('/', insertLogsToDb);
+    router.post('/find', findLogs);
+    return router;
+};
+export default getLogRoutes;

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

@@ -1,7 +1,8 @@
-import { globalOasTlmConfig } from '../config.js';
+import { inMemoryDbMetricExporter } from '../telemetry/telemetryRegistry.js';
+import { convertRegexRecursively } from '../utils/regexUtils.js';
 export const listMetrics = async (req, res) => {
     try {
-        const metrics = globalOasTlmConfig.metricsExporter.getFinishedMetrics();
+        const metrics = inMemoryDbMetricExporter.getFinishedMetrics();
         res.send({ metricsCount: metrics.length, metrics: metrics });
     }
     catch (err) {
@@ -11,8 +12,17 @@ export const listMetrics = async (req, res) => {
 };
 export const findMetrics = (req, res) => {
     const body = req.body;
-    const search = body?.search ? body.search : {};
-    globalOasTlmConfig.metricsExporter.find(search, (err, docs) => {
+    const query = body?.query ? body.query : {};
+    let processedQuery;
+    try {
+        processedQuery = convertRegexRecursively(query);
+    }
+    catch (error) {
+        console.error(error.message);
+        res.status(400).send({ error: error.message });
+        return; // Exit if invalid regex was encountered
+    }
+    inMemoryDbMetricExporter.find(processedQuery, (err, docs) => {
         if (err) {
             console.error(err);
             res.status(404).send({ metricsCount: 0, metrics: [], error: err });
@@ -23,7 +33,7 @@ export const findMetrics = (req, res) => {
     });
 };
 export const resetMetrics = (req, res) => {
-    globalOasTlmConfig.metricsExporter.reset();
+    inMemoryDbMetricExporter.reset();
     res.send('Metrics reset');
 };
 export const insertMetricsToDb = async (req, res) => {
@@ -41,11 +51,11 @@ export const insertMetricsToDb = async (req, res) => {
     try {
         let message = '';
         if (resetData) {
-            globalOasTlmConfig.metricsExporter.reset();
+            inMemoryDbMetricExporter.reset();
             message += 'Metrics Database reset. ';
         }
         await new Promise((resolve, reject) => {
-            globalOasTlmConfig.metricsExporter.insert(cleanedMetrics, (err, newDocs) => {
+            inMemoryDbMetricExporter.insert(cleanedMetrics, (err, newDocs) => {
                 if (err) {
                     console.error('Error inserting metrics:', err);
                     return reject(err);
@@ -62,14 +72,23 @@ export const insertMetricsToDb = async (req, res) => {
     }
 };
 export const startMetrics = (req, res) => {
-    globalOasTlmConfig.metricsExporter.start();
+    inMemoryDbMetricExporter.enable();
     res.send('Metrics collection started');
 };
 export const stopMetrics = (req, res) => {
-    globalOasTlmConfig.metricsExporter.stop();
+    inMemoryDbMetricExporter.disable();
     res.send('Metrics collection stopped');
 };
 export const statusMetrics = (req, res) => {
-    const isRunning = globalOasTlmConfig.metricsExporter.isRunning() || false;
+    const isRunning = inMemoryDbMetricExporter.isEnabled() || false;
     res.send({ active: isRunning });
 };
+export const setRetentionTimeMetrics = (req, res) => {
+    const retentionTime = req.body.retentionTime;
+    if (typeof retentionTime !== 'number' || retentionTime <= 0) {
+        res.status(400).send({ error: 'Invalid retention time. Must be a positive number.' });
+        return;
+    }
+    inMemoryDbMetricExporter.retentionTimeInSeconds = retentionTime;
+    res.send({ message: `Retention time set to ${retentionTime} seconds.` });
+};

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

@@ -1,12 +1,16 @@
 import { Router } from 'express';
-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;
+import { listMetrics, findMetrics, resetMetrics, insertMetricsToDb, startMetrics, stopMetrics, statusMetrics, setRetentionTimeMetrics } from './metricsController.js';
+export const getMetricsRoutes = () => {
+    const router = Router();
+    // Metrics Control
+    router.post('/start', startMetrics);
+    router.post('/stop', stopMetrics);
+    router.get('/status', statusMetrics);
+    router.post('/reset', resetMetrics);
+    router.post('/retention-time', setRetentionTimeMetrics);
+    router.get('/', listMetrics);
+    router.post('/', insertMetricsToDb);
+    router.post('/find', findMetrics);
+    return router;
+};
+export default getMetricsRoutes;

package/dist/esm/tlm-plugin/pluginController.js

@@ -1,29 +1,51 @@
-import { globalOasTlmConfig } from '../config.js';
 import axios from 'axios';
 // @ts-expect-error: import-from-string does not have proper type declarations
 import { importFromString, requireFromString } from 'import-from-string';
 // @ts-expect-error: dynamic-installer does not have proper type declarations
 import { installDependencies } from 'dynamic-installer';
 import logger from '../utils/logger.js';
+import { pluginService } from './pluginService.js';
 export const listPlugins = (req, res) => {
-    res.send(globalOasTlmConfig.dynamicSpanExporter.getPlugins().map((plugin) => {
+    const plugins = pluginService.getPlugins().map((plugin) => {
         return {
             id: plugin.id,
             name: plugin.name,
             url: plugin.url,
             active: plugin.active
         };
-    }));
+    });
+    res.send({
+        pluginsCount: plugins.length,
+        plugins: plugins
+    });
 };
 export const registerPlugin = async (req, res) => {
-    const pluginResource = req.body;
-    logger.info(`Plugin Registration Request: = ${JSON.stringify(req.body, null, 2)}...`);
-    logger.info(`Getting plugin at ${pluginResource.url}...`);
     let pluginCode;
+    const pluginResource = req.body;
+    logger.debug(`Plugin Registration Request: = ${JSON.stringify(req.body, null, 2)}...`);
+    // Validate plugin id
+    if (!pluginResource.id || typeof pluginResource.id !== "string") {
+        res.status(400).send(`Plugin id must be provided and must be a string`);
+        return;
+    }
+    // Check for duplicate plugin id
+    const existingPlugin = pluginService.getPlugins().find((plugin) => plugin.id === pluginResource.id);
+    if (existingPlugin) {
+        res.status(400).send(`A plugin with id "${pluginResource.id}" already exists.`);
+        return;
+    }
     if (!pluginResource.url && !pluginResource.code) {
         res.status(400).send(`Plugin code or URL must be provided`);
         return;
     }
+    if (!pluginResource.moduleFormat) {
+        res.status(400).send(`Plugin moduleFormat must be provided (e.g., "cjs" or "esm")`);
+        return;
+    }
+    if (!["cjs", "esm"].includes(pluginResource.moduleFormat.toLowerCase())) {
+        res.status(400).send(`Invalid moduleFormat "${pluginResource.moduleFormat}". Supported formats are "cjs" and "esm".`);
+        return;
+    }
     let module;
     try {
         if (pluginResource.code) {
@@ -38,6 +60,7 @@ export const registerPlugin = async (req, res) => {
             return;
         }
         if (pluginResource.install) {
+            logger.info("Installing dependencies for plugin: " + pluginResource.name);
             const dependenciesStatus = await installDependencies(pluginResource.install);
             if (!dependenciesStatus.success) {
                 if (pluginResource.install.ignoreErrors === true) {
@@ -49,16 +72,14 @@ export const registerPlugin = async (req, res) => {
                 }
             }
         }
-        logger.info("Plugin size: " + pluginCode?.length);
-        logger.info("Plugin format: " + pluginResource?.moduleFormat);
-        if (pluginResource?.moduleFormat && pluginResource.moduleFormat.toUpperCase() == "ESM") {
+        logger.debug("Plugin format (provided): " + pluginResource?.moduleFormat);
+        if (pluginResource.moduleFormat.toLowerCase() === "esm") {
             logger.info("ESM detected");
             module = await importFromString(pluginCode);
         }
         else {
             logger.info("CJS detected (default)");
             module = await requireFromString(pluginCode);
-            logger.info(module);
         }
     }
     catch (error) {
@@ -67,14 +88,14 @@ export const registerPlugin = async (req, res) => {
         return;
     }
     const plugin = module.default?.plugin ?? module.plugin;
-    if (plugin == undefined) {
-        res.status(400).send(`Plugin code should export a "plugin" object`);
-        logger.info("Error in plugin code: no plugin object exported");
+    if (!plugin) {
+        res.status(400).send(`Plugin code should export a valid "plugin" object or static class`);
+        logger.info("Error in plugin code: no valid plugin object exported");
         return;
     }
     for (const requiredFunction of ["load", "getName", "isConfigured"]) {
-        if (plugin[requiredFunction] == undefined) {
-            res.status(400).send(`The plugin code exports a "plugin" object, however it should have a "${requiredFunction}" method`);
+        if (typeof plugin[requiredFunction] !== "function") {
+            res.status(400).send(`The plugin code exports a "plugin" object, but it must have a "${requiredFunction}" method`);
             logger.info("Error in plugin code: some required functions are missing");
             return;
         }
@@ -89,15 +110,15 @@ export const registerPlugin = async (req, res) => {
     }
     if (plugin.isConfigured()) {
         logger.info(`Loaded plugin <${plugin.getName()}>`);
-        pluginResource.plugin = plugin;
+        pluginResource.pluginImplementation = plugin;
         pluginResource.name = plugin.getName();
         pluginResource.active = true;
-        globalOasTlmConfig.dynamicSpanExporter.pushPlugin(pluginResource);
-        globalOasTlmConfig.dynamicSpanExporter.activatePlugin(pluginResource.plugin);
+        pluginService.pushPlugin(pluginResource);
+        pluginService.activatePlugin(pluginResource);
         res.status(201).send(`Plugin registered`);
     }
     else {
-        logger.error(`Plugin <${plugin.getName()}> can not be configured`);
+        logger.error(`Plugin <${plugin.getName()}> cannot be configured`);
         res.status(400).send(`Plugin configuration problem`);
     }
 };

package/dist/esm/tlm-plugin/pluginRoutes.js

@@ -1,7 +1,8 @@
 import { Router } from 'express';
 import { listPlugins, registerPlugin } from './pluginController.js';
-export const pluginRoutes = Router();
-// Plugins
-pluginRoutes.get('/plugins', listPlugins);
-pluginRoutes.post('/plugins', registerPlugin);
-export default pluginRoutes;
+export const getPluginRoutes = () => {
+    const router = Router();
+    router.get('/', listPlugins);
+    router.post('/', registerPlugin);
+    return router;
+};

package/dist/esm/tlm-plugin/pluginService.js

@@ -0,0 +1,19 @@
+class PluginService {
+    constructor() {
+        this.plugins = [];
+    }
+    getPlugins() {
+        return this.plugins;
+    }
+    pushPlugin(plugin) {
+        this.plugins.push(plugin);
+    }
+    activatePlugin(plugin) {
+        this.plugins.forEach(p => {
+            if (p.id === plugin.id) {
+                p.active = true;
+            }
+        });
+    }
+}
+export const pluginService = new PluginService();

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

@@ -1,52 +1,48 @@
-import { globalOasTlmConfig } from '../config.js';
-export const startTelemetry = (req, res) => {
-    globalOasTlmConfig.dynamicSpanExporter.exporter.start();
-    res.send('Telemetry started');
+import { inMemoryDbSpanExporter } from '../telemetry/telemetryRegistry.js';
+import { convertRegexRecursively } from '../utils/regexUtils.js';
+export const startTraces = (req, res) => {
+    inMemoryDbSpanExporter.enable();
+    res.send('Traces started');
 };
-export const stopTelemetry = (req, res) => {
-    globalOasTlmConfig.dynamicSpanExporter.exporter.stop();
-    res.send('Telemetry stopped');
+export const stopTraces = (req, res) => {
+    inMemoryDbSpanExporter.disable();
+    res.send('Traces stopped');
 };
-export const statusTelemetry = (req, res) => {
-    const isRunning = globalOasTlmConfig.dynamicSpanExporter.exporter.isRunning() || false;
+export const statusTraces = (req, res) => {
+    const isRunning = inMemoryDbSpanExporter.isEnabled() || false;
     res.send({ active: isRunning });
 };
-export const resetTelemetry = (req, res) => {
-    globalOasTlmConfig.dynamicSpanExporter.exporter.reset();
-    res.send('Telemetry reset');
+export const resetTraces = (req, res) => {
+    inMemoryDbSpanExporter.reset();
+    res.send('Traces reset');
 };
-export const listTelemetry = async (req, res) => {
+export const listTraces = async (req, res) => {
     try {
-        const spans = await globalOasTlmConfig.dynamicSpanExporter.exporter.getFinishedSpans();
+        const spans = inMemoryDbSpanExporter.getFinishedSpans();
         res.send({ spansCount: spans.length, spans: spans });
     }
     catch (err) {
         console.error(err);
-        res.status(500).send({ error: 'Failed to list telemetry data' });
+        res.status(500).send({ error: 'Failed to list traces data' });
     }
 };
-export const findTelemetry = (req, res) => {
+export const findTraces = (req, res) => {
     const body = req.body;
-    const search = body?.search ? body.search : {};
-    if (body?.flags?.containsRegex) {
-        try {
-            //@ts-expect-error yes
-            body.config?.regexIds?.forEach(regexId => {
-                if (search[regexId])
-                    search[regexId] = new RegExp(search[regexId]);
-            });
-        }
-        catch (e) {
-            console.error(e);
-            res.status(404).send({ spansCount: 0, spans: [], error: e });
-            return;
-        }
+    const query = body?.query ? body.query : {};
+    let processedQuery;
+    try {
+        processedQuery = convertRegexRecursively(query);
     }
-    globalOasTlmConfig.dynamicSpanExporter.exporter.find(search, (err, docs) => {
+    catch (error) {
+        console.error(error.message);
+        res.status(400).send({ error: error.message });
+        return; // Exit if invalid regex was encountered
+    }
+    inMemoryDbSpanExporter.find(processedQuery, (err, docs) => {
         if (err) {
             console.error(err);
-            res.status(404).send({ spansCount: 0, spans: [], error: err });
-            return;
+            res.status(404).send({ spansCount: 0, spans: [], error: err.message });
+            return; // Exit the function to prevent further execution
         }
         const spans = docs;
         res.send({ spansCount: spans.length, spans: spans });
@@ -67,11 +63,11 @@ export const insertTracesToDb = async (req, res) => {
     try {
         let message = '';
         if (resetData) {
-            globalOasTlmConfig.dynamicSpanExporter.exporter.reset();
+            inMemoryDbSpanExporter.reset();
             message += 'Traces Database reset. ';
         }
         await new Promise((resolve, reject) => {
-            globalOasTlmConfig.dynamicSpanExporter.exporter.insert(cleanedTraces, (err, newDocs) => {
+            inMemoryDbSpanExporter.insert(cleanedTraces, (err, newDocs) => {
                 if (err) {
                     console.error('Error inserting traces:', err);
                     return reject(err);
@@ -87,3 +83,12 @@ export const insertTracesToDb = async (req, res) => {
         res.status(500).send({ error: 'Failed to reset and insert data', details: err.message });
     }
 };
+export const setRetentionTimeTraces = (req, res) => {
+    const retentionTime = req.body.retentionTime;
+    if (typeof retentionTime !== 'number' || retentionTime <= 0) {
+        res.status(400).send({ error: 'Invalid retention time. Must be a positive number.' });
+        return;
+    }
+    inMemoryDbSpanExporter.retentionTimeInSeconds = retentionTime;
+    res.send({ message: `Retention time set to ${retentionTime} seconds.` });
+};

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

@@ -1,12 +1,16 @@
 import { Router } from 'express';
-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);
-traceRoutes.get('/stop', stopTelemetry);
-traceRoutes.get('/status', statusTelemetry);
-traceRoutes.get('/reset', resetTelemetry);
-export default traceRoutes;
+import { startTraces, stopTraces, statusTraces, resetTraces, listTraces, findTraces, insertTracesToDb, setRetentionTimeTraces } from './traceController.js';
+export const getTraceRoutes = () => {
+    const router = Router();
+    // Telemetry Control
+    router.post('/start', startTraces);
+    router.post('/stop', stopTraces);
+    router.get('/status', statusTraces);
+    router.post('/reset', resetTraces);
+    router.get('/', listTraces);
+    router.post('/', insertTracesToDb);
+    router.post('/find', findTraces);
+    router.post('/retention-time', setRetentionTimeTraces);
+    return router;
+};
+export default getTraceRoutes;

package/dist/esm/tlm-ui/uiRoutes.js

@@ -2,22 +2,27 @@ import express, { Router } from 'express';
 import path from 'path';
 import { fileURLToPath } from 'url';
 import logger from '../utils/logger.js';
-let relativePath = '../../ui';
-if (process.env.OASTLM_ENV === 'development') {
-    relativePath = '../../dist/ui';
-    logger.warn('🚧 This process is serving the OASTLM UI from the build directory, but you are in development mode. For live updates, run the React app separately and access it at http://localhost:5173/.');
-}
-const customFilename = fileURLToPath(import.meta.url);
-const customDirname = path.dirname(customFilename);
-const staticFilesPath = path.join(customDirname, relativePath);
-export const uiRoutes = Router();
-// This only works once the app is built: src/ --> dist/esm/
-// This file: dist/esm/routes/
-// UI bundle: dist/ui/
-// For development, the UI is served separately.
-uiRoutes.use(express.static(staticFilesPath));
-uiRoutes.get('*', (_req, res) => {
-    // Serve the index.html file for all routes
-    res.sendFile(path.join(staticFilesPath, 'index.html'));
-});
-export default uiRoutes;
+import { bootEnvVariables } from '../config/bootConfig.js';
+export const getUIRoutes = () => {
+    // This is when this file is in /dist
+    let relativePath = '../../ui';
+    // This is when this file in in /src
+    if (bootEnvVariables.OASTLM_BOOT_ENV === 'development') {
+        relativePath = '../../dist/ui';
+        logger.warn('🚧 This process is serving the OASTLM UI from the build directory, but you are in development mode. For live updates, run the React app separately and access it at http://localhost:5173/.');
+    }
+    const customFilename = fileURLToPath(import.meta.url);
+    const customDirname = path.dirname(customFilename);
+    const staticFilesPath = path.join(customDirname, relativePath);
+    const router = Router();
+    // This only works once the app is built: src/ --> dist/esm/
+    // This file: dist/esm/routes/
+    // UI bundle: dist/ui/
+    // For development, the UI is served separately.
+    router.use(express.static(staticFilesPath));
+    router.get('*', (_req, res) => {
+        // Serve the index.html file for all routes
+        res.sendFile(path.join(staticFilesPath, 'index.html'));
+    });
+    return router;
+};