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

package/dist/cjs/tlm-trace/traceRoutes.cjs

@@ -3,16 +3,21 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.traceRoutes = exports.default = void 0;
+exports.getTraceRoutes = exports.default = void 0;
 var _express = require("express");
 var _traceController = require("./traceController.cjs");
-const traceRoutes = exports.traceRoutes = (0, _express.Router)();
-traceRoutes.get('/', _traceController.listTelemetry);
-traceRoutes.post('/', _traceController.insertTracesToDb);
-traceRoutes.post('/find', _traceController.findTelemetry);
-// Telemetry Control
-traceRoutes.get('/start', _traceController.startTelemetry);
-traceRoutes.get('/stop', _traceController.stopTelemetry);
-traceRoutes.get('/status', _traceController.statusTelemetry);
-traceRoutes.get('/reset', _traceController.resetTelemetry);
-var _default = exports.default = traceRoutes;
+const getTraceRoutes = () => {
+  const router = (0, _express.Router)();
+  // Telemetry Control
+  router.post('/start', _traceController.startTraces);
+  router.post('/stop', _traceController.stopTraces);
+  router.get('/status', _traceController.statusTraces);
+  router.post('/reset', _traceController.resetTraces);
+  router.get('/', _traceController.listTraces);
+  router.post('/', _traceController.insertTracesToDb);
+  router.post('/find', _traceController.findTraces);
+  router.post('/retention-time', _traceController.setRetentionTimeTraces);
+  return router;
+};
+exports.getTraceRoutes = getTraceRoutes;
+var _default = exports.default = getTraceRoutes;

package/dist/cjs/tlm-ui/uiRoutes.cjs

@@ -3,29 +3,35 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.uiRoutes = exports.default = void 0;
+exports.getUIRoutes = void 0;
 var _express = _interopRequireWildcard(require("express"));
 var _path = _interopRequireDefault(require("path"));
 var _url = require("url");
 var _logger = _interopRequireDefault(require("../utils/logger.cjs"));
+var _bootConfig = require("../config/bootConfig.cjs");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
-let relativePath = '../../ui';
-if (process.env.OASTLM_ENV === 'development') {
-  relativePath = '../../dist/ui';
-  _logger.default.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 = (0, _url.fileURLToPath)(require('url').pathToFileURL(__filename).toString());
-const customDirname = _path.default.dirname(customFilename);
-const staticFilesPath = _path.default.join(customDirname, relativePath);
-const uiRoutes = exports.uiRoutes = (0, _express.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.default.static(staticFilesPath));
-uiRoutes.get('*', (_req, res) => {
-  // Serve the index.html file for all routes
-  res.sendFile(_path.default.join(staticFilesPath, 'index.html'));
-});
-var _default = exports.default = uiRoutes;
+const getUIRoutes = () => {
+  // This is when this file is in /dist
+  let relativePath = '../../ui';
+  // This is when this file in in /src
+  if (_bootConfig.bootEnvVariables.OASTLM_BOOT_ENV === 'development') {
+    relativePath = '../../dist/ui';
+    _logger.default.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 = (0, _url.fileURLToPath)(require('url').pathToFileURL(__filename).toString());
+  const customDirname = _path.default.dirname(customFilename);
+  const staticFilesPath = _path.default.join(customDirname, relativePath);
+  const router = (0, _express.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.default.static(staticFilesPath));
+  router.get('*', (_req, res) => {
+    // Serve the index.html file for all routes
+    res.sendFile(_path.default.join(staticFilesPath, 'index.html'));
+  });
+  return router;
+};
+exports.getUIRoutes = getUIRoutes;

package/dist/cjs/tlm-util/utilController.cjs

@@ -4,20 +4,19 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.specLoader = exports.heapStats = void 0;
-var _config = require("../config.cjs");
 var _fs = require("fs");
 var _path = _interopRequireDefault(require("path"));
 var _jsYaml = _interopRequireDefault(require("js-yaml"));
 var _nodeV = _interopRequireDefault(require("node:v8"));
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-const specLoader = (_req, res) => {
-  if (_config.globalOasTlmConfig.specFileName) {
+const specLoader = (_req, res, oasTlmConfig) => {
+  if (oasTlmConfig.general.specFileName) {
     try {
-      const data = (0, _fs.readFileSync)(_config.globalOasTlmConfig.specFileName, {
+      const data = (0, _fs.readFileSync)(oasTlmConfig.general.specFileName, {
         encoding: 'utf8',
         flag: 'r'
       });
-      const extension = _path.default.extname(_config.globalOasTlmConfig.specFileName);
+      const extension = _path.default.extname(oasTlmConfig.general.specFileName);
       let json = data;
       if (extension == "yaml")
         //@ts-expect-error yes
@@ -25,15 +24,15 @@ const specLoader = (_req, res) => {
       res.setHeader('Content-Type', 'application/json');
       res.send(json);
     } catch (e) {
-      console.error(`ERROR loading spec file ${_config.globalOasTlmConfig.specFileName}: ${e}`);
+      console.error(`ERROR loading spec file ${oasTlmConfig.general.specFileName}: ${e}`);
     }
-  } else if (_config.globalOasTlmConfig.spec) {
+  } else if (oasTlmConfig.general.spec) {
     let spec = null;
     try {
-      spec = JSON.parse(_config.globalOasTlmConfig.spec);
+      spec = JSON.parse(oasTlmConfig.general.spec);
     } catch (ej) {
       try {
-        spec = JSON.stringify(_jsYaml.default.load(_config.globalOasTlmConfig.spec), null, 2);
+        spec = JSON.stringify(_jsYaml.default.load(oasTlmConfig.general.spec), null, 2);
       } catch (ey) {
         console.error(`Error parsing spec: ${ej} - ${ey}`);
       }

package/dist/cjs/tlm-util/utilRoutes.cjs

@@ -3,26 +3,29 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.utilsRoutes = exports.default = void 0;
+exports.getUtilsRoutes = void 0;
 var _express = require("express");
 var _utilController = require("./utilController.cjs");
-const utilsRoutes = exports.utilsRoutes = (0, _express.Router)();
-utilsRoutes.get('/spec', _utilController.specLoader);
-utilsRoutes.get('/heapStats', _utilController.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
+const getUtilsRoutes = oasTlmConfig => {
+  const router = (0, _express.Router)();
+  router.get('/spec', (req, res) => (0, _utilController.specLoader)(req, res, oasTlmConfig));
+  router.get('/heapStats', _utilController.heapStats);
+  router.get('/generateLog', (req, res) => {
+    const log = req.query.log || 'Default log message';
+    console.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
+  router.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
+    });
   });
-});
-var _default = exports.default = utilsRoutes;
+  return router;
+};
+exports.getUtilsRoutes = getUtilsRoutes;

package/dist/cjs/types/index.cjs

@@ -4,5 +4,4 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 ;
-;
 ;

package/dist/cjs/utils/logger.cjs

@@ -4,12 +4,10 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
-var _dotenv = _interopRequireDefault(require("dotenv"));
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-_dotenv.default.config();
+var _bootConfig = require("../config/bootConfig.cjs");
 const LOG_LEVELS = ['DEBUG', 'INFO', 'WARN', 'ERROR', 'NONE'];
-const currentLogLevel = (process.env.OASTLM_LOG_LEVEL || 'INFO').toUpperCase();
-const serviceName = process.env.OASTLM_SERVICE_NAME || 'OAS-TLM';
+const currentLogLevel = (_bootConfig.bootEnvVariables.OASTLM_BOOT_LOG_LEVEL || 'INFO').toUpperCase();
+const serviceName = 'OAS-Telemetry';
 function log(level, ...messages) {
   if (LOG_LEVELS.indexOf(level) >= LOG_LEVELS.indexOf(currentLogLevel)) {
     const timestamp = new Date().toISOString();

package/dist/cjs/utils/regexUtils.cjs

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.convertRegexRecursively = void 0;
+const convertRegexRecursively = obj => {
+  if (Array.isArray(obj)) {
+    return obj.map(convertRegexRecursively);
+  } else if (obj && typeof obj === 'object') {
+    const newObj = {};
+    for (const key of Object.keys(obj)) {
+      if (key === '$regex' && typeof obj[key] === 'string') {
+        try {
+          return new RegExp(obj[key]);
+        } catch {
+          throw new Error(`Invalid regex value "${obj[key]}"`);
+        }
+      } else {
+        newObj[key] = convertRegexRecursively(obj[key]);
+      }
+    }
+    return newObj;
+  }
+  return obj;
+};
+exports.convertRegexRecursively = convertRegexRecursively;

package/dist/esm/config/bootConfig.js

@@ -0,0 +1,11 @@
+import dotenv from 'dotenv';
+if (process.env.NODE_ENV !== 'test') {
+    dotenv.config();
+}
+// This variables can NOT be configured via oasTelemetry(config)
+// They are used at the import of the library
+export const bootEnvVariables = {
+    OASTLM_BOOT_ENV: process.env.OASTLM_BOOT_ENV || process.env.NODE_ENV || 'production',
+    OASTLM_BOOT_MODULE_DISABLED: process.env.OASTLM_BOOT_MODULE_DISABLED === 'true',
+    OASTLM_BOOT_LOG_LEVEL: process.env.OASTLM_BOOT_LOG_LEVEL || 'INFO',
+};

package/dist/esm/config/config.js

@@ -0,0 +1,126 @@
+import merge from 'lodash.merge';
+// Environment-level config (highest priority)
+// If NOT defined, it should return UNDEFINED so it dose not override the userConfig or defaultConfig.
+// Thats why we use getParsedEnvVar with no default value.
+const loadEnv = () => {
+    return {
+        general: {
+            baseUrl: getParsedEnvVar("OASTLM_CONFIG_GENERAL_BASE_URL"),
+            specFileName: getParsedEnvVar("OASTLM_CONFIG_GENERAL_SPEC_FILE_NAME"),
+            // spec Not settable via env
+        },
+        auth: {
+            enabled: getParsedEnvVar("OASTLM_CONFIG_AUTH_ENABLED", (v) => v === "true"),
+            apiKeyMaxAge: getParsedEnvVar("OASTLM_CONFIG_AUTH_API_KEY_MAX_AGE", (v) => parseInt(v, 10)),
+            password: getParsedEnvVar("OASTLM_CONFIG_AUTH_PASSWORD"),
+            jwtSecret: getParsedEnvVar("OASTLM_CONFIG_AUTH_JWT_SECRET"),
+        },
+        traces: {
+            memoryExporter: {
+                enabled: getParsedEnvVar("OASTLM_CONFIG_TRACES_MEMORY_EXPORTER_ENABLED", (v) => v === "true"),
+                retentionTimeSeconds: getParsedEnvVar("OASTLM_CONFIG_TRACES_MEMORY_EXPORTER_RETENTION_TIME_SECONDS", (v) => parseInt(v, 10)),
+                // filters NOT settable via env
+            }
+        },
+        metrics: {
+            mainMetricReaderOptions: {
+                exportIntervalMillis: getParsedEnvVar("OASTLM_CONFIG_METRICS_MAIN_READER_EXPORT_INTERVAL", (v) => parseInt(v, 10)),
+                // metricProducers NOT settable via env
+            },
+            memoryExporter: {
+                enabled: getParsedEnvVar("OASTLM_CONFIG_METRICS_MEMORY_EXPORTER_ENABLED", (v) => v === "true"),
+                retentionTimeSeconds: getParsedEnvVar("OASTLM_CONFIG_METRICS_MEMORY_EXPORTER_RETENTION_TIME_SECONDS", (v) => parseInt(v, 10)),
+                // filters NOT settable via env
+            }
+        },
+        logs: {
+            memoryExporter: {
+                enabled: getParsedEnvVar("OASTLM_CONFIG_LOGS_MEMORY_EXPORTER_ENABLED", (v) => v === "true"),
+                retentionTimeSeconds: getParsedEnvVar("OASTLM_CONFIG_LOGS_MEMORY_EXPORTER_RETENTION_TIME_SECONDS", (v) => parseInt(v, 10)),
+                // filters NOT settable via env
+            },
+        },
+        ai: {
+            openAIKey: getParsedEnvVar("OASTLM_CONFIG_AI_OPENAI_KEY"),
+            openAIModel: getParsedEnvVar("OASTLM_CONFIG_AI_OPENAI_MODEL", (v) => v || "gpt-3.5-turbo"),
+            extraContextPrompts: getParsedEnvVar("OASTLM_CONFIG_AI_EXTRA_CONTEXT_PROMPTS", (v) => v ? v.split(',') : []),
+        },
+    };
+};
+// This defines de OasTlmConfig type, which is used throughout the library.
+// Please ensure that all possible types are included here, not only the defaults.
+// e.g. .ai.openAIKey: null as string | null, default is null, but can be set to a string.
+// NOTE: Some BOOT environment variables (e.g., OASTLM_BOOT_MODULE_DISABLED) are accessed before this config is loaded.
+// This means certain settings may affect application startup behavior outside of this configuration system.
+export const defaultConfig = {
+    general: {
+        baseUrl: "/telemetry",
+        specFileName: null, // e.g. "oas.json" or null if not provided
+        spec: null, // e.g. JSON.stringify(oasSpec) or null if not provided,
+        uiPath: "/oas-telemetry-ui", // path to the UI, e.g. "/oas-telemetry-ui" WARN: This must match the UI package's App.tsx "oas-telemetry-ui" path
+    },
+    auth: {
+        enabled: false,
+        apiKeyMaxAge: 1000 * 60 * 60, // 1 hour
+        password: "oas-telemetry-password",
+        jwtSecret: "oas-telemetry-secret",
+    },
+    ai: {
+        openAIKey: null,
+        openAIModel: "gpt-3.5-turbo",
+        extraContextPrompts: [], // e.g. ["Provide detailed explanations", "Use simple language"]
+    },
+    traces: {
+        extraExporters: [], // e.g. [new ConsoleSpanExporter()]
+        extraProcessors: [], // e.g. [new SimpleSpanProcessor(new ConsoleSpanExporter())]
+        mainProcessorOptions: {
+            config: undefined
+        },
+        memoryExporter: {
+            enabled: true, // auto start exporting.
+            retentionTimeSeconds: 60 * 60, // 1 hour
+        },
+        filters: [], // future feature, currently not used
+    },
+    metrics: {
+        mainMetricReaderOptions: {
+            exportIntervalMillis: 1000 * 60, // 60 seconds
+            metricProducers: [], // experimental by OpenTelemetry, not used by OAS-TLM yet
+        },
+        extraReaders: [], // e.g. [new PrometheusExporter()]
+        extraViews: [], // e.g. [new MetricView({ name: 'my_metric', labels: ['env'] })]
+        memoryExporter: {
+            enabled: true,
+            retentionTimeSeconds: 60 * 60, // 1 hour
+        },
+        filters: [], // future feature, currently not used
+    },
+    logs: {
+        extraExporters: [], // e.g. [new ConsoleLogRecordExporter()]
+        extraProcessors: [], // e.g. [new SimpleLogRecordProcessor(new ConsoleLogRecordExporter())]
+        memoryExporter: {
+            enabled: true,
+            retentionTimeSeconds: 60 * 60, // 1 hour
+        },
+        filters: [], // future feature, currently not used
+    },
+    plugins: {
+        enabled: true, // future feature
+        extraPlugins: [], // future feature
+    },
+};
+// Helper to get an environment variable with optional transform
+const getParsedEnvVar = (envKey, transform) => {
+    const rawValue = process.env[envKey];
+    // Treat undefined and "" in env as undefined (skip)
+    if (rawValue === undefined || rawValue === "")
+        return undefined;
+    if (typeof transform === 'function') {
+        return transform(rawValue);
+    }
+    return rawValue;
+};
+export const getConfig = (userConfig, fallbackConfig = defaultConfig, envConfig = loadEnv()) => {
+    // environment variables OVERRIDE userConfig OVERRIDE fallbackConfig
+    return merge({}, fallbackConfig, userConfig, envConfig);
+};

package/dist/esm/index.js

@@ -1,39 +1,28 @@
-import './instrumentation/index.js';
-import { globalOasTlmConfig } from './config.js';
-import { Router } from 'express';
-import { InMemoryExporter } from './exporters/InMemoryDbExporter.js';
+import "./config/bootConfig.js"; // Load environment variables before any other imports
+import './telemetry/initializeTelemetry.js'; // Initialize OpenTelemetry instrumentation
 import logger from './utils/logger.js';
-import { configureRoutes } from './tlmRoutes.js';
+import { getConfig } from './config/config.js';
+import { Router } from 'express';
+import { configureRoutes } from './routesManager.js';
+import { configureTelemetry } from './telemetry/telemetryConfigurator.js';
+import { bootEnvVariables } from "./config/bootConfig.js";
 /**
- * Returns the Oas Telemetry middleware. The parameters are the same as `globalOasTlmConfig`.
+ * Returns the OAS-Telemetry middleware.
  * All parameters are optional. However, either `spec` or `specFileName` must be provided to enable endpoint filtering.
  */
 export default function oasTelemetry(oasTlmInputConfig) {
     const router = Router();
-    if (process.env.OASTLM_MODULE_DISABLED === 'true') {
+    // This environment variable cannot be set via the config object,
+    // as it is required to disable OpenTelemetry SDK initialization,
+    // which occurs during the first import at the top of this file.
+    if (bootEnvVariables.OASTLM_BOOT_MODULE_DISABLED) {
         return router;
     }
-    if (oasTlmInputConfig) {
-        logger.info("User provided config");
-        // Override global config with user provided config
-        for (const key in globalOasTlmConfig) {
-            globalOasTlmConfig[key] = oasTlmInputConfig[key] ?? globalOasTlmConfig[key];
-        }
-    }
-    logger.info("BaseURL: ", globalOasTlmConfig.baseURL);
-    globalOasTlmConfig.dynamicSpanExporter.changeExporter(globalOasTlmConfig.exporter ?? new InMemoryExporter());
-    if (globalOasTlmConfig.spec)
-        logger.info(`Spec content provided`);
-    else {
-        if (globalOasTlmConfig.specFileName != "")
-            logger.info(`Spec file used for telemetry: ${globalOasTlmConfig.specFileName}`);
-        else {
-            console.error("No spec available !");
-        }
-    }
-    if (globalOasTlmConfig.autoActivate) {
-        globalOasTlmConfig.dynamicSpanExporter.exporter?.start();
-    }
-    configureRoutes(router);
+    const oasTlmConfig = getConfig(oasTlmInputConfig);
+    logger.info("BaseUrl: ", oasTlmConfig.general.baseUrl);
+    if (!oasTlmConfig.general.spec && !oasTlmConfig.general.specFileName)
+        logger.warn("No spec provided, endpoint filtering will not be available. Please provide either `spec` or `specFileName` in the configuration.");
+    configureTelemetry(oasTlmConfig);
+    configureRoutes(router, oasTlmConfig);
     return router;
 }

package/dist/esm/{tlmRoutes.js → routesManager.js}

@@ -1,18 +1,19 @@
 import { json } from "express";
 import logger from "./utils/logger.js";
 import cors from 'cors';
-import { globalOasTlmConfig } from "./config.js";
-import metricsRoutes from "./tlm-metric/metricsRoutes.js";
+import { getTraceRoutes } from "./tlm-trace/traceRoutes.js";
+import { getMetricsRoutes } from "./tlm-metric/metricsRoutes.js";
+import { getLogRoutes } from "./tlm-log/logRoutes.js";
 import cookieParser from 'cookie-parser';
-import authRoutes from './tlm-auth/authRoutes.js';
-import uiRoutes from './tlm-ui/uiRoutes.js';
-import traceRoutes from "./tlm-trace/traceRoutes.js";
-import { authMiddleware } from "./tlm-auth/authMiddleware.js";
-import utilsRoutes from "./tlm-util/utilRoutes.js";
-import logRoutes from './tlm-log/logRoutes.js';
-import aiRoutes from "./tlm-ai/aiRoutes.js";
-export const configureRoutes = (router) => {
-    if (process.env.OASTLM_ENV === 'development') {
+import { getAuthRoutes } from './tlm-auth/authRoutes.js';
+import { getUIRoutes } from './tlm-ui/uiRoutes.js';
+import { getAuthMiddleware } from "./tlm-auth/authMiddleware.js";
+import { getUtilsRoutes } from "./tlm-util/utilRoutes.js";
+import { getAIRoutes } from "./tlm-ai/aiRoutes.js";
+import { bootEnvVariables } from "./config/bootConfig.js";
+import { getPluginRoutes } from "./tlm-plugin/pluginRoutes.js";
+export const configureRoutes = (router, oasTlmConfig) => {
+    if (bootEnvVariables.OASTLM_BOOT_ENV === 'development') {
         logger.info("Running in development mode, enabling CORS for all origins");
         router.use(cors({
             origin: '*', // Permitir todas las solicitudes en desarrollo
@@ -26,19 +27,23 @@ export const configureRoutes = (router) => {
         }
         return json({ limit: '10mb' })(req, res, next);
     });
-    const allAuthMiddlewares = getWrappedMiddlewares(() => globalOasTlmConfig.authEnabled, [cookieParser(), authRoutes, authMiddleware]);
-    const baseURL = globalOasTlmConfig.baseURL;
-    router.use(baseURL, allAuthMiddlewares);
+    const allAuthMiddlewares = getWrappedMiddlewares(() => oasTlmConfig.auth.enabled, [cookieParser(), getAuthRoutes(oasTlmConfig), getAuthMiddleware(oasTlmConfig)]);
+    const baseUrl = oasTlmConfig.general.baseUrl;
+    router.use(baseUrl, allAuthMiddlewares);
+    router.use(baseUrl + "/traces", getTraceRoutes());
+    router.use(baseUrl + "/metrics", getMetricsRoutes());
+    router.use(baseUrl + "/logs", getLogRoutes());
+    router.use(baseUrl + "/ai", getWrappedMiddlewares(() => oasTlmConfig.ai.openAIKey !== null, [getAIRoutes(oasTlmConfig)]));
     // WARNING: This path must be the same as the one used in the UI package App.tsx "oas-telemetry-ui"
-    router.use(baseURL + "/traces", traceRoutes);
-    router.use(baseURL + "/metrics", metricsRoutes);
-    router.use(baseURL + "/logs", logRoutes);
-    router.use(baseURL + "/ai", getWrappedMiddlewares(() => process.env.OASTLM_AI_OPENAI_API_KEY !== null && process.env.OASTLM_AI_OPENAI_API_KEY !== "", [aiRoutes]));
-    router.use(baseURL + "/oas-telemetry-ui", uiRoutes);
-    router.use(baseURL + "/utils", utilsRoutes);
+    router.use(baseUrl + "/oas-telemetry-ui", getUIRoutes());
+    router.use(baseUrl + "/utils", getUtilsRoutes(oasTlmConfig));
+    router.use(baseUrl + "/plugins", getPluginRoutes());
+    router.get(baseUrl + '/health', (_req, res) => {
+        res.status(200).send({ status: 'OK' });
+    });
     //redirect to the UI when accessing the base URL
-    router.get(baseURL, (req, res) => {
-        res.redirect(baseURL + "/oas-telemetry-ui");
+    router.get(baseUrl, (req, res) => {
+        res.redirect(baseUrl + "/oas-telemetry-ui");
     });
 };
 /**

package/dist/esm/{exporters/InMemoryLogRecordExporter.js → telemetry/custom-implementations/exporters/InMemoryDbLogExporter.js}

@@ -1,17 +1,22 @@
 import { hrTimeToMicroseconds } from '@opentelemetry/core';
 import { ExportResultCode } from '@opentelemetry/core';
-import { removeCircularRefs, applyNesting } from '../utils/circular.js';
 import Datastore from '@seald-io/nedb';
 import MiniSearch from 'minisearch';
-export class InMemoryLogRecordExporter {
-    constructor() {
-        this._db = new Datastore();
+import { applyNesting, removeCircularRefs } from '../utils/circular.js';
+import { Enabler } from '../wrappers.js';
+import logger from '../../../utils/logger.js';
+export class InMemoryDbLogExporter extends Enabler {
+    constructor(retentionTimeInSeconds = 3600) {
+        super();
+        this._retentionTimeInSeconds = retentionTimeInSeconds;
+        this._db = new Datastore({ timestampData: true });
+        this._db.ensureIndex({ fieldName: 'createdAt' });
         this._miniSearch = new MiniSearch({
             fields: ['body'],
             storeFields: ['_id'],
             idField: '_id',
         });
-        this._stopped = false;
+        this._startCleanupJob();
     }
     /*
     * SUPER WARNING:
@@ -25,7 +30,7 @@ export class InMemoryLogRecordExporter {
      * @param resultCallback
      */
     export(logs, resultCallback) {
-        if (this._stopped) {
+        if (!this.isEnabled()) {
             resultCallback({ code: ExportResultCode.SUCCESS });
             return;
         }
@@ -57,7 +62,7 @@ export class InMemoryLogRecordExporter {
         if (messageSearch) {
             const searchResults = this._miniSearch.search(messageSearch);
             const ids = searchResults.map((result) => result._id);
-            console.dir(`MiniSearch found ${ids.length} results for search term "${messageSearch}"`, { depth: 3 });
+            logger.debug(`MiniSearch found ${ids.length} results for search term "${messageSearch}"`, { depth: 3 });
             // Add MiniSearch results to the query
             query._id = { $in: ids };
         }
@@ -68,7 +73,7 @@ export class InMemoryLogRecordExporter {
             if (result.code === ExportResultCode.SUCCESS) {
                 this._db.find({}, (err, docs) => {
                     if (err) {
-                        console.dir(err);
+                        logger.debug(err);
                         callback(err, []);
                         return;
                     }
@@ -80,15 +85,6 @@ export class InMemoryLogRecordExporter {
             }
         });
     }
-    start() {
-        this._stopped = false;
-    }
-    stop() {
-        this._stopped = true;
-    }
-    isRunning() {
-        return !this._stopped;
-    }
     getFinishedLogs() {
         return this._db.getAllData();
     }
@@ -114,6 +110,10 @@ export class InMemoryLogRecordExporter {
             attributes: logRecord.attributes,
         };
     }
+    set retentionTimeInSeconds(retentionTimeInSeconds) {
+        this._retentionTimeInSeconds = retentionTimeInSeconds;
+        logger.info(`InMemoryDbLogExporter retention time set to ${this._retentionTimeInSeconds} seconds`);
+    }
     _insertLogs(logsToInsert, resultCallback) {
         this._db.insert(logsToInsert, (err, newDocs) => {
             if (err) {
@@ -127,4 +127,18 @@ export class InMemoryLogRecordExporter {
         });
         return;
     }
+    _startCleanupJob() {
+        const interval = 1000;
+        setInterval(() => {
+            const expirationDate = new Date(Date.now() - this._retentionTimeInSeconds * 1000);
+            this._db.remove({ createdAt: { $lt: expirationDate } }, { multi: true }, (err, numRemoved) => {
+                if (err) {
+                    logger.error('Error in TTL cleanup:', err);
+                }
+                else if (numRemoved > 0) {
+                    logger.debug(`TTL cleanup: removed ${numRemoved} expired logs`);
+                }
+            });
+        }, interval);
+    }
 }