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

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

@@ -0,0 +1,101 @@
+// pluginProcess.js
+// Runs inside a child process, isolated from the main app
+// @ts-expect-error no types
+import { importFromString, requireFromString } from "import-from-string";
+import { installDependencies } from "dynamic-installer";
+let plugin;
+const log = (...args) => {
+    console.log(`[PluginProcess:${process.pid}]`, ...args);
+};
+process.on("message", async (msg) => {
+    if (msg.type === "load") {
+        try {
+            const pluginResource = normalizePluginResource(msg.pluginResource);
+            if (pluginResource.install && Array.isArray(pluginResource.install.dependencies) && pluginResource.install.dependencies.length > 0) {
+                log("Installing dependencies for plugin: " + pluginResource.name);
+                const dependenciesStatus = await installDependencies(pluginResource.install);
+                if (!dependenciesStatus.success) {
+                    if (pluginResource.install.ignoreErrors === true) {
+                        log(`Warning: Error installing dependencies: ${JSON.stringify(dependenciesStatus.details)}`);
+                    }
+                    else {
+                        process.send?.({ event: "error", error: `Error installing dependencies: ${JSON.stringify(dependenciesStatus.details)}` });
+                        return;
+                    }
+                }
+            }
+            let module;
+            if (pluginResource?.moduleFormat?.toLowerCase() === "esm") {
+                module = await importFromString(pluginResource.sourceCode);
+            }
+            else {
+                module = await requireFromString(pluginResource.sourceCode);
+            }
+            plugin = module.default?.plugin ?? module.plugin;
+            if (!plugin)
+                throw new Error("Plugin must export a valid 'plugin' object");
+            for (const fn of ["load", "isConfigured"]) {
+                if (typeof plugin[fn] !== "function") {
+                    throw new Error(`Plugin is missing required function "${fn}"`);
+                }
+            }
+            await plugin.load(pluginResource.config);
+            if (!plugin.isConfigured()) {
+                throw new Error("Plugin could not be configured");
+            }
+            process.send?.({ event: "loaded", name: pluginResource.name || pluginResource.id || "unknown" });
+        }
+        catch (err) {
+            process.send?.({ event: "error", error: err.message });
+            process.exit(1);
+        }
+    }
+    // Forward log/metric/trace calls
+    if (msg.type === "newLog" && plugin?.newLog) {
+        plugin.newLog(msg.payload);
+    }
+    if (msg.type === "newMetric" && plugin?.newMetric) {
+        plugin.newMetric(msg.payload);
+    }
+    if (msg.type === "newTrace" && plugin?.newTrace) {
+        plugin.newTrace(msg.payload);
+    }
+    if (msg.type === "unload") {
+        if (plugin && typeof plugin.unload === "function") {
+            await plugin.unload();
+        }
+        process.send?.({ event: "unloaded" });
+        process.exit(0);
+    }
+});
+function normalizePluginResource(raw) {
+    let resource = raw;
+    // case: received as stringified JSON
+    if (typeof raw === "string") {
+        try {
+            resource = JSON.parse(raw);
+        }
+        catch (err) {
+            throw new Error("Invalid pluginResource JSON: " + err.message);
+        }
+    }
+    // normalize install
+    if (typeof resource.install === "string") {
+        try {
+            resource.install = JSON.parse(resource.install);
+        }
+        catch (err) {
+            throw new Error("Invalid install JSON: " + err.message);
+        }
+    }
+    // normalize config
+    if (typeof resource.config === "string") {
+        try {
+            resource.config = JSON.parse(resource.config);
+        }
+        catch (err) {
+            throw new Error("Invalid config JSON: " + err.message);
+        }
+    }
+    return resource;
+}

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

@@ -1,7 +1,11 @@
 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;
+import { listPlugins, registerPlugin, activatePlugin, deactivatePlugin, deletePlugin } from './pluginController.js';
+export const getPluginRoutes = () => {
+    const router = Router();
+    router.get('/', listPlugins);
+    router.post('/', registerPlugin);
+    router.post('/:id/activate', activatePlugin);
+    router.post('/:id/deactivate', deactivatePlugin);
+    router.delete('/:id', deletePlugin);
+    return router;
+};

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

@@ -0,0 +1,73 @@
+import logger from "../utils/logger.js";
+class PluginService {
+    constructor() {
+        this.plugins = [];
+    }
+    getPlugins() {
+        return this.plugins;
+    }
+    pushPlugin(plugin) {
+        this.plugins.push(plugin);
+    }
+    activatePlugin(pluginId) {
+        const plugin = this.plugins.find((p) => p.id === pluginId);
+        if (plugin) {
+            plugin.active = true;
+        }
+    }
+    deactivatePlugin(pluginId) {
+        const plugin = this.plugins.find((p) => p.id === pluginId);
+        if (plugin) {
+            plugin.active = false;
+        }
+    }
+    deletePlugin(pluginId) {
+        const plugin = this.plugins.find((p) => p.id === pluginId);
+        if (plugin?.process && !plugin.process.killed) {
+            plugin.process.kill(1);
+        }
+        this.plugins = this.plugins.filter((p) => p.id !== pluginId);
+    }
+    broadcastToPlugins(type, payload) {
+        this.plugins.forEach((plugin, i) => {
+            if (!plugin.active)
+                return;
+            if (plugin.process) {
+                if (plugin.process.connected) {
+                    try {
+                        plugin.process.send({ type, payload });
+                        logger.debug(`Sent ${type} to child-process plugin <${plugin.name}> (#${i})`);
+                    }
+                    catch (err) {
+                        logger.error(`Failed to send ${type} to plugin <${plugin.name}> (#${i}):`, err);
+                    }
+                }
+                else {
+                    logger.warn(`Plugin <${plugin.name}> (#${i}) is not connected. Skipping ${type}.`);
+                }
+            }
+            else {
+                logger.debug(`Plugin <${plugin.name}> does not implement ${type}. Skipping.`);
+            }
+        });
+    }
+    /**
+     * Broadcast a new metric to all active plugins
+     */
+    broadcastMetric(metric) {
+        this.broadcastToPlugins("newMetric", metric);
+    }
+    /**
+     * Broadcast a new log to all active plugins
+     */
+    broadcastLog(log) {
+        this.broadcastToPlugins("newLog", log);
+    }
+    /**
+     * Broadcast a new trace to all active plugins
+     */
+    broadcastTrace(trace) {
+        this.broadcastToPlugins("newTrace", trace);
+    }
+}
+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;
+};

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

@@ -1,13 +1,12 @@
-import { globalOasTlmConfig } from '../config.js';
 import { readFileSync } from 'fs';
 import path from 'path';
 import yaml from 'js-yaml';
 import v8 from 'node:v8';
-export const specLoader = (_req, res) => {
-    if (globalOasTlmConfig.specFileName) {
+export const specLoader = (_req, res, oasTlmConfig) => {
+    if (oasTlmConfig.general.specFileName) {
         try {
-            const data = readFileSync(globalOasTlmConfig.specFileName, { encoding: 'utf8', flag: 'r' });
-            const extension = path.extname(globalOasTlmConfig.specFileName);
+            const data = readFileSync(oasTlmConfig.general.specFileName, { encoding: 'utf8', flag: 'r' });
+            const extension = path.extname(oasTlmConfig.general.specFileName);
             let json = data;
             if (extension == "yaml")
                 //@ts-expect-error yes
@@ -16,17 +15,17 @@ export const specLoader = (_req, res) => {
             res.send(json);
         }
         catch (e) {
-            console.error(`ERROR loading spec file ${globalOasTlmConfig.specFileName}: ${e}`);
+            console.error(`ERROR loading spec file ${oasTlmConfig.general.specFileName}: ${e}`);
         }
     }
-    else if (globalOasTlmConfig.spec) {
+    else if (oasTlmConfig.general.spec) {
         let spec = null;
         try {
-            spec = JSON.parse(globalOasTlmConfig.spec);
+            spec = JSON.parse(oasTlmConfig.general.spec);
         }
         catch (ej) {
             try {
-                spec = JSON.stringify(yaml.load(globalOasTlmConfig.spec), null, 2);
+                spec = JSON.stringify(yaml.load(oasTlmConfig.general.spec), null, 2);
             }
             catch (ey) {
                 console.error(`Error parsing spec: ${ej} - ${ey}`);

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

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

package/dist/esm/types/index.js

@@ -1,4 +1,3 @@
 ;
 ;
-;
 export {};

package/dist/esm/utils/logger.js

@@ -1,8 +1,7 @@
-import dotenv from 'dotenv';
-dotenv.config();
+import { bootEnvVariables } from "../config/bootConfig.js";
 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 = (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/esm/utils/regexUtils.js

@@ -0,0 +1,23 @@
+export 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;
+};

package/dist/types/config/bootConfig.d.ts

@@ -0,0 +1,5 @@
+export declare const bootEnvVariables: {
+    OASTLM_BOOT_ENV: string;
+    OASTLM_BOOT_MODULE_DISABLED: boolean;
+    OASTLM_BOOT_LOG_LEVEL: string;
+};