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

package/dist/esm/tlm-ai/tools.js

@@ -1,13 +1,13 @@
 import axios from 'axios';
-import { globalOasTlmConfig } from '../config.js';
 import logger from '../utils/logger.js';
 import { getKnownMicroservices } from './knownMicroservices.js';
+import { inMemoryDbLogExporter, inMemoryDbMetricExporter, inMemoryDbSpanExporter } from '../telemetry/telemetryRegistry.js';
 const getTraces = async (searchInput) => {
     logger.debug("getTraces called with searchInput:", searchInput);
     try {
         const search = searchInput || {};
         const traces = await new Promise((resolve, reject) => {
-            globalOasTlmConfig.dynamicSpanExporter.exporter.find(search, (err, docs) => {
+            inMemoryDbSpanExporter.find(search, (err, docs) => {
                 if (err)
                     reject(err);
                 else
@@ -42,7 +42,7 @@ const getLogs = async (startDate, endDate) => {
         }
         const logs = [];
         await new Promise((resolve, reject) => {
-            globalOasTlmConfig.logExporter.find(nedbQuery, null, (err, docs) => {
+            inMemoryDbLogExporter.find(nedbQuery, null, (err, docs) => {
                 if (err) {
                     reject(err);
                 }
@@ -66,7 +66,7 @@ const getMetrics = async (searchInput) => {
     try {
         const search = searchInput || {};
         const metrics = await new Promise((resolve, reject) => {
-            globalOasTlmConfig.metricsExporter.find(search, (err, docs) => {
+            inMemoryDbMetricExporter.find(search, (err, docs) => {
                 if (err)
                     reject(err);
                 else
@@ -90,20 +90,29 @@ const getCurrentTimestampInEpoch = () => {
 };
 const startTelemetry = () => {
     logger.debug("Starting telemetry...");
-    globalOasTlmConfig.dynamicSpanExporter.exporter.start();
+    inMemoryDbSpanExporter.enable();
+    inMemoryDbLogExporter.enable();
+    inMemoryDbMetricExporter.enable();
 };
 const stopTelemetry = () => {
     logger.debug("Stopping telemetry...");
-    globalOasTlmConfig.dynamicSpanExporter.exporter.stop();
+    inMemoryDbSpanExporter.disable();
+    inMemoryDbLogExporter.disable();
+    inMemoryDbMetricExporter.disable();
 };
 const resetTelemetry = () => {
     logger.debug("Resetting telemetry...");
-    globalOasTlmConfig.dynamicSpanExporter.exporter.reset();
+    inMemoryDbSpanExporter.reset();
+    inMemoryDbLogExporter.reset();
+    inMemoryDbMetricExporter.reset();
 };
 const getTelemetryStatus = () => {
     logger.debug("Getting telemetry status...");
-    const isRunning = globalOasTlmConfig.dynamicSpanExporter.exporter.isRunning() || false;
-    return { active: isRunning };
+    return {
+        spansEnabled: inMemoryDbSpanExporter.isEnabled(),
+        logsEnabled: inMemoryDbLogExporter.isEnabled(),
+        metricsEnabled: inMemoryDbMetricExporter.isEnabled()
+    };
 };
 const talkToExternalMicroserviceAgent = async (message, microserviceId) => {
     logger.debug("talkToExternalMicroserviceAgent called with question:", message, "microservice:", microserviceId);

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

@@ -1,17 +1,16 @@
-import { globalOasTlmConfig } from '../config.js';
 import jwt from 'jsonwebtoken';
 import logger from '../utils/logger.js';
-export const login = (req, res) => {
+export const getLogin = (oasTlmConfig) => (req, res) => {
     try {
         const { password } = req.body;
-        if (password === globalOasTlmConfig.password) {
+        if (password === oasTlmConfig.auth.password) {
             const options = {
-                maxAge: globalOasTlmConfig.apiKeyMaxAge,
+                maxAge: oasTlmConfig.auth.apiKeyMaxAge,
                 httpOnly: true,
                 secure: true,
                 signed: false
             };
-            const apiKey = jwt.sign({ password: globalOasTlmConfig.password }, globalOasTlmConfig.jwtSecret);
+            const apiKey = jwt.sign({ password: oasTlmConfig.auth.password }, oasTlmConfig.auth.jwtSecret);
             res.cookie('apiKey', apiKey, options);
             res.status(200).json({ valid: true, message: 'API Key is valid' });
             return;
@@ -23,17 +22,17 @@ export const login = (req, res) => {
         res.status(500).json({ valid: false, message: 'Internal server error' });
     }
 };
-export const logout = (req, res) => {
+export const getLogout = (oasTlmConfig) => (req, res) => {
     res.clearCookie('apiKey');
-    res.redirect(globalOasTlmConfig.baseURL + '/login');
+    res.redirect(oasTlmConfig.general.baseUrl + oasTlmConfig.general.uiPath + '/login');
 };
-export const check = (req, res) => {
+export const getCheck = (oasTlmConfig) => (req, res) => {
     if (!req.cookies.apiKey) {
         res.status(200).json({ valid: false, message: 'API Key is invalid' });
         return;
     }
-    const decoded = jwt.verify(req.cookies.apiKey, globalOasTlmConfig.jwtSecret);
-    if (decoded.password === globalOasTlmConfig.password) {
+    const decoded = jwt.verify(req.cookies.apiKey, oasTlmConfig.auth.jwtSecret);
+    if (decoded.password === oasTlmConfig.auth.password) {
         res.status(200).json({ valid: true, message: 'API Key is valid' });
         return;
     }

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,103 +1,138 @@
-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 axios from "axios";
+import { fork } from "child_process";
+import path from "path";
+import logger from "../utils/logger.js";
+import { pluginService } from "./pluginService.js";
+import { fileURLToPath } from "url";
 export const listPlugins = (req, res) => {
-    res.send(globalOasTlmConfig.dynamicSpanExporter.getPlugins().map((plugin) => {
-        return {
-            id: plugin.id,
-            name: plugin.name,
-            url: plugin.url,
-            active: plugin.active
-        };
-    }));
+    const plugins = pluginService.getPlugins();
+    res.send({
+        pluginsCount: plugins.length,
+        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;
+    logger.debug(`Plugin Registration Request: ${JSON.stringify(req.body, null, 2)}...`);
+    // Validate id
+    if (!pluginResource.id || typeof pluginResource.id !== "string") {
+        res.status(400).send("Plugin id must be provided and must be a string");
+        return;
+    }
+    // Check duplicate
+    if (pluginService.getPlugins().find((p) => p.id === pluginResource.id)) {
+        res.status(400).send(`Plugin with id "${pluginResource.id}" already exists.`);
+        return;
+    }
+    // Validate inputs
     if (!pluginResource.url && !pluginResource.code) {
-        res.status(400).send(`Plugin code or URL must be provided`);
+        res.status(400).send("Plugin code or URL must be provided");
         return;
     }
-    let module;
+    if (!pluginResource.moduleFormat) {
+        res.status(400).send("Plugin moduleFormat must be provided (cjs|esm)");
+        return;
+    }
+    // Fetch code
+    let pluginCode;
     try {
         if (pluginResource.code) {
             pluginCode = pluginResource.code;
         }
         else {
+            console.log(pluginResource.url);
             const response = await axios.get(pluginResource.url);
             pluginCode = response.data;
         }
-        if (!pluginCode) {
-            res.status(400).send(`Plugin code could not be loaded`);
-            return;
-        }
-        if (pluginResource.install) {
-            const dependenciesStatus = await installDependencies(pluginResource.install);
-            if (!dependenciesStatus.success) {
-                if (pluginResource.install.ignoreErrors === true) {
-                    logger.warn(`Warning: Error installing dependencies: ${JSON.stringify(dependenciesStatus.details)}`);
-                }
-                else {
-                    res.status(400).send(`Error installing dependencies: ${JSON.stringify(dependenciesStatus.details)}`);
-                    return;
-                }
-            }
-        }
-        logger.info("Plugin size: " + pluginCode?.length);
-        logger.info("Plugin format: " + pluginResource?.moduleFormat);
-        if (pluginResource?.moduleFormat && pluginResource.moduleFormat.toUpperCase() == "ESM") {
-            logger.info("ESM detected");
-            module = await importFromString(pluginCode);
-        }
-        else {
-            logger.info("CJS detected (default)");
-            module = await requireFromString(pluginCode);
-            logger.info(module);
-        }
+        pluginResource.sourceCode = pluginCode;
     }
-    catch (error) {
-        logger.error(`Error loading plugin: ${error}`);
-        res.status(400).send(`Error loading plugin: ${error}`);
+    catch (err) {
+        res.status(400).send(`Error fetching plugin code: ${err}`);
         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 (!pluginCode) {
+        res.status(400).send("Plugin code could not be loaded");
         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`);
-            logger.info("Error in plugin code: some required functions are missing");
-            return;
+    const isCjs = typeof __filename !== "undefined" && typeof __dirname !== "undefined";
+    const __filenameUniversal = isCjs
+        ? __filename
+        : fileURLToPath(import.meta.url);
+    const __dirnameUniversal = isCjs
+        ? __dirname
+        : path.dirname(__filenameUniversal);
+    const pluginProcessFile = isCjs
+        ? "pluginProcess.cjs"
+        : "pluginProcess.js";
+    const child = fork(path.resolve(__dirnameUniversal, pluginProcessFile), [], {
+        stdio: ["pipe", "pipe", "pipe", "ipc"],
+    });
+    child.stdout?.on("data", (data) => {
+        logger.info(`[Plugin ${pluginResource.id}] STDOUT: ${data.toString().trim()}`);
+    });
+    child.stderr?.on("data", (data) => {
+        logger.error(`[Plugin ${pluginResource.id}] STDERR: ${data.toString().trim()}`);
+    });
+    child.on("message", (msg) => {
+        if (msg.event === "loaded") {
+            pluginResource.name = msg.name;
+            pluginResource.active = true;
+            pluginResource.process = child;
+            pluginService.pushPlugin(pluginResource);
+            res.status(201).send(`Plugin ${msg.name} registered`);
         }
-    }
-    try {
-        await plugin.load(pluginResource.config);
-    }
-    catch (error) {
-        logger.error(`Error loading plugin configuration: ${error}`);
-        res.status(400).send(`Error loading plugin configuration: ${error}`);
+        else if (msg.event === "error") {
+            res.status(400).send(`Error loading plugin: ${msg.error}`);
+        }
+    });
+    child.on("exit", (code) => {
+        pluginResource.active = false;
+        pluginResource.process = undefined;
+        logger.warn(`Plugin ${pluginResource.id} exited (code: ${code})`);
+    });
+    child.on("disconnect", () => {
+        pluginResource.active = false;
+        pluginResource.process = undefined;
+        logger.warn(`Plugin ${pluginResource.id} disconnected`);
+    });
+    child.on("error", (err) => {
+        pluginResource.active = false;
+        pluginResource.process = undefined;
+        logger.error(`Plugin ${pluginResource.id} error: ${err.message}`);
+    });
+    // Send data to child
+    child.send({
+        type: "load",
+        pluginResource,
+    });
+};
+export const activatePlugin = (req, res) => {
+    const { id } = req.params;
+    const plugin = pluginService.getPlugins().find((p) => p.id === id);
+    if (!plugin) {
+        res.status(404).send(`Plugin with id "${id}" not found.`);
         return;
     }
-    if (plugin.isConfigured()) {
-        logger.info(`Loaded plugin <${plugin.getName()}>`);
-        pluginResource.plugin = plugin;
-        pluginResource.name = plugin.getName();
-        pluginResource.active = true;
-        globalOasTlmConfig.dynamicSpanExporter.pushPlugin(pluginResource);
-        globalOasTlmConfig.dynamicSpanExporter.activatePlugin(pluginResource.plugin);
-        res.status(201).send(`Plugin registered`);
+    pluginService.activatePlugin(id);
+    res.status(200).send(`Plugin "${id}" activated.`);
+};
+export const deactivatePlugin = (req, res) => {
+    const { id } = req.params;
+    const plugin = pluginService.getPlugins().find((p) => p.id === id);
+    if (!plugin) {
+        res.status(404).send(`Plugin with id "${id}" not found.`);
+        return;
     }
-    else {
-        logger.error(`Plugin <${plugin.getName()}> can not be configured`);
-        res.status(400).send(`Plugin configuration problem`);
+    pluginService.deactivatePlugin(id); // This only sets active to false
+    res.status(200).send(`Plugin "${id}" deactivated.`);
+};
+export const deletePlugin = (req, res) => {
+    const { id } = req.params;
+    const plugin = pluginService.getPlugins().find((p) => p.id === id);
+    if (!plugin) {
+        res.status(404).send(`Plugin with id "${id}" not found.`);
+        return;
     }
+    pluginService.deletePlugin(id); // kills child inside service
+    res.status(200).send(`Plugin "${id}" deleted.`);
 };