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

package/README.md

@@ -1,6 +1,7 @@
 # OAS TELEMETRY
 
-**OAS Telemetry** is an Express middleware for collecting telemetry data using **OpenTelemetry** in **OpenAPI Specification (OAS)**-based applications. It exposes endpoints for managing and analyzing telemetry data—such as starting/stopping collection, resetting, listing, and searching records—making integration with **Express.js** straightforward.
+
+**OAS Telemetry** is a library that automatically configures telemetry in your Express application based on OpenAPI, with no extra code required. Simply use the middleware to instantly access endpoints for viewing recent requests, system logs, and metrics—all stored in memory. This allows you to analyze your API’s behavior and debug issues easily, without manual setup or complex integration. OpenTelemetry is used under the hood to collect traces, metrics, and logs.
 
 The middleware is highly configurable and supports both **ES Module (ESM)** and **CommonJS (CJS)** formats (ESM targeting **ES2020**). Its functionality can be extended via plugins; see [Telemetry Plugins](#telemetry-plugins) for details.
 
@@ -8,11 +9,13 @@ The middleware is highly configurable and supports both **ES Module (ESM)** and
 >
 > **OAS Telemetry** is a functional and working package, but it is currently at version 0 and remains under active development. Features, APIs, and behavior are subject to change at any time. Please review the following current status before use:
 >
-> - **Traces:** Semi-stable. Currently supports HTTP instrumentation.
+> - **Traces:** Semi-stable. Currently supports HTTP instrumentation. We are studying switching to auto-instrumentation, but we need to test memory usage and performance first.
 > - **Logs:** Semi-stable. Supports fast search by message content and Mongo-like search (similar to traces).
-> - **Metrics:** Semi=stable. Currently uses OpenTelemetry host metrics. This area is subject to change to improve memory usage and data handling.
+> - **Metrics:** Not stable. Currently uses OpenTelemetry host metrics. This area is subject to change to improve memory usage and data handling.
 > - **Configuration:** Semi-stable. All configuration options will be available as parameters at initialization and via environment variables (see the `.env.example` file). The configuration system is under active development and will change significantly in future releases.
-> - **UI:** Not stable. Migration to React is in progress. Most views are placeholders except for the AI agent, which is fully functional and can answer questions about metrics, traces, and logs.
+> - **UI:** Not stable. Migration to React is in progress. Most views are placeholders except for the AI agent, which is fully functional and can answer questions about traces, and logs (Not yet for metrics). Plugin management page is also functional. Next steps include logs page (almost done) and traces page (subject to change based on instrumentation approach). Metrics page will be the last to be implemented, as we want to support custom metrics in the future.
+>
+> Please if you want to use this package contact us via motero6@us.es
 
 ## Usage
 

package/dist/cjs/telemetry/custom-implementations/exporters/PluginLogExporter.cjs

@@ -24,15 +24,8 @@ class PluginLogExporter extends _wrappers.Enabler {
         });
       }
       const cleanLogs = logs.map(log => (0, _circular.removeCircularRefs)(log)).map(log => (0, _circular.applyNesting)(log));
-      _pluginService.pluginService.getPlugins().forEach((pluginResource, i) => {
-        if (typeof pluginResource.pluginImplementation.newLog === 'function') {
-          cleanLogs.forEach(log => {
-            _logger.default.debug(`Sending log to plugin (Plugin #${i}) <${pluginResource.name}>`);
-            pluginResource.pluginImplementation.newLog(log);
-          });
-        } else {
-          _logger.default.debug(`Plugin <${pluginResource.name}> does not implement newLog method. Skipping log export.`);
-        }
+      cleanLogs.forEach(log => {
+        _pluginService.pluginService.broadcastLog(log);
       });
       setTimeout(() => resultCallback({
         code: _core.ExportResultCode.SUCCESS

package/dist/cjs/telemetry/custom-implementations/exporters/PluginMetricExporter.cjs

@@ -24,14 +24,7 @@ class PluginMetricExporter extends _wrappers.Enabler {
         });
       }
       const cleanMetrics = (0, _circular.applyNesting)((0, _circular.removeCircularRefs)(metrics));
-      _pluginService.pluginService.getPlugins().forEach((pluginResource, i) => {
-        if (typeof pluginResource.pluginImplementation.newMetric === 'function') {
-          _logger.default.debug(`Sending metric to plugin (Plugin #${i}) <${pluginResource.name}>`);
-          pluginResource.pluginImplementation.newMetric(cleanMetrics);
-        } else {
-          _logger.default.debug(`Plugin <${pluginResource.name}> does not implement newMetric method. Skipping metric export.`);
-        }
-      });
+      _pluginService.pluginService.broadcastMetric(cleanMetrics);
       setTimeout(() => resultCallback({
         code: _core.ExportResultCode.SUCCESS
       }), 0);

package/dist/cjs/telemetry/custom-implementations/exporters/PluginSpanExporter.cjs

@@ -37,16 +37,8 @@ class PluginSpanExporter extends _wrappers.Enabler {
         }
         return true;
       });
-      _pluginService.pluginService.getPlugins().forEach((pluginResource, i) => {
-        if (typeof pluginResource.pluginImplementation.newTrace === 'function') {
-          cleanSpans.forEach(span => {
-            _logger.default.debug(`Sending span to plugin (Plugin #${i}) <${pluginResource.name}>`);
-            //TODO: This should be called newSpan instead of newTrace
-            pluginResource.pluginImplementation.newTrace(span);
-          });
-        } else {
-          _logger.default.debug(`Plugin <${pluginResource.name}> does not implement newTrace method. Skipping span export.`);
-        }
+      cleanSpans.forEach(span => {
+        _pluginService.pluginService.broadcastTrace(span);
       });
       setTimeout(() => resultCallback({
         code: _core.ExportResultCode.SUCCESS

package/dist/cjs/tlm-plugin/pluginController.cjs

@@ -3,127 +3,145 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.registerPlugin = exports.listPlugins = void 0;
+exports.registerPlugin = exports.listPlugins = exports.deletePlugin = exports.deactivatePlugin = exports.activatePlugin = void 0;
 var _axios = _interopRequireDefault(require("axios"));
-var _importFromString = require("import-from-string");
-var _dynamicInstaller = require("dynamic-installer");
+var _child_process = require("child_process");
+var _path = _interopRequireDefault(require("path"));
 var _logger = _interopRequireDefault(require("../utils/logger.cjs"));
 var _pluginService = require("./pluginService.cjs");
+var _url = require("url");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-// @ts-expect-error: import-from-string does not have proper type declarations
-
-// @ts-expect-error: dynamic-installer does not have proper type declarations
-
 const listPlugins = (req, res) => {
-  const plugins = _pluginService.pluginService.getPlugins().map(plugin => {
-    return {
-      id: plugin.id,
-      name: plugin.name,
-      url: plugin.url,
-      active: plugin.active
-    };
-  });
+  const plugins = _pluginService.pluginService.getPlugins();
   res.send({
     pluginsCount: plugins.length,
-    plugins: plugins
+    plugins
   });
 };
 exports.listPlugins = listPlugins;
 const registerPlugin = async (req, res) => {
-  let pluginCode;
   const pluginResource = req.body;
-  _logger.default.debug(`Plugin Registration Request: = ${JSON.stringify(req.body, null, 2)}...`);
-  // Validate plugin id
+  _logger.default.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`);
+    res.status(400).send("Plugin id must be provided and must be a string");
     return;
   }
-  // Check for duplicate plugin id
-  const existingPlugin = _pluginService.pluginService.getPlugins().find(plugin => plugin.id === pluginResource.id);
-  if (existingPlugin) {
-    res.status(400).send(`A plugin with id "${pluginResource.id}" already exists.`);
+  // Check duplicate
+  if (_pluginService.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;
   }
   if (!pluginResource.moduleFormat) {
-    res.status(400).send(`Plugin moduleFormat must be provided (e.g., "cjs" or "esm")`);
+    res.status(400).send("Plugin moduleFormat must be provided (cjs|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;
+  // Fetch code
+  let pluginCode;
   try {
     if (pluginResource.code) {
       pluginCode = pluginResource.code;
     } else {
+      console.log(pluginResource.url);
       const response = await _axios.default.get(pluginResource.url);
       pluginCode = response.data;
     }
-    if (!pluginCode) {
-      res.status(400).send(`Plugin code could not be loaded`);
-      return;
-    }
-    if (pluginResource.install) {
-      _logger.default.info("Installing dependencies for plugin: " + pluginResource.name);
-      const dependenciesStatus = await (0, _dynamicInstaller.installDependencies)(pluginResource.install);
-      if (!dependenciesStatus.success) {
-        if (pluginResource.install.ignoreErrors === true) {
-          _logger.default.warn(`Warning: Error installing dependencies: ${JSON.stringify(dependenciesStatus.details)}`);
-        } else {
-          res.status(400).send(`Error installing dependencies: ${JSON.stringify(dependenciesStatus.details)}`);
-          return;
-        }
-      }
-    }
-    _logger.default.debug("Plugin format (provided): " + pluginResource?.moduleFormat);
-    if (pluginResource.moduleFormat.toLowerCase() === "esm") {
-      _logger.default.info("ESM detected");
-      module = await (0, _importFromString.importFromString)(pluginCode);
-    } else {
-      _logger.default.info("CJS detected (default)");
-      module = await (0, _importFromString.requireFromString)(pluginCode);
-    }
-  } catch (error) {
-    _logger.default.error(`Error loading plugin: ${error}`);
-    res.status(400).send(`Error loading plugin: ${error}`);
+    pluginResource.sourceCode = pluginCode;
+  } catch (err) {
+    res.status(400).send(`Error fetching plugin code: ${err}`);
     return;
   }
-  const plugin = module.default?.plugin ?? module.plugin;
-  if (!plugin) {
-    res.status(400).send(`Plugin code should export a valid "plugin" object or static class`);
-    _logger.default.info("Error in plugin code: no valid plugin object exported");
+  if (!pluginCode) {
+    res.status(400).send("Plugin code could not be loaded");
     return;
   }
-  for (const requiredFunction of ["load", "getName", "isConfigured"]) {
-    if (typeof plugin[requiredFunction] !== "function") {
-      res.status(400).send(`The plugin code exports a "plugin" object, but it must have a "${requiredFunction}" method`);
-      _logger.default.info("Error in plugin code: some required functions are missing");
-      return;
+  const isCjs = typeof __filename !== "undefined" && typeof __dirname !== "undefined";
+  const __filenameUniversal = isCjs ? __filename : (0, _url.fileURLToPath)(require('url').pathToFileURL(__filename).toString());
+  const __dirnameUniversal = isCjs ? __dirname : _path.default.dirname(__filenameUniversal);
+  const pluginProcessFile = isCjs ? "pluginProcess.cjs" : "pluginProcess.js";
+  const child = (0, _child_process.fork)(_path.default.resolve(__dirnameUniversal, pluginProcessFile), [], {
+    stdio: ["pipe", "pipe", "pipe", "ipc"]
+  });
+  child.stdout?.on("data", data => {
+    _logger.default.info(`[Plugin ${pluginResource.id}] STDOUT: ${data.toString().trim()}`);
+  });
+  child.stderr?.on("data", data => {
+    _logger.default.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.pluginService.pushPlugin(pluginResource);
+      res.status(201).send(`Plugin ${msg.name} registered`);
+    } 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.default.warn(`Plugin ${pluginResource.id} exited (code: ${code})`);
+  });
+  child.on("disconnect", () => {
+    pluginResource.active = false;
+    pluginResource.process = undefined;
+    _logger.default.warn(`Plugin ${pluginResource.id} disconnected`);
+  });
+  child.on("error", err => {
+    pluginResource.active = false;
+    pluginResource.process = undefined;
+    _logger.default.error(`Plugin ${pluginResource.id} error: ${err.message}`);
+  });
+  // Send data to child
+  child.send({
+    type: "load",
+    pluginResource
+  });
+};
+exports.registerPlugin = registerPlugin;
+const activatePlugin = (req, res) => {
+  const {
+    id
+  } = req.params;
+  const plugin = _pluginService.pluginService.getPlugins().find(p => p.id === id);
+  if (!plugin) {
+    res.status(404).send(`Plugin with id "${id}" not found.`);
+    return;
   }
-  try {
-    await plugin.load(pluginResource.config);
-  } catch (error) {
-    _logger.default.error(`Error loading plugin configuration: ${error}`);
-    res.status(400).send(`Error loading plugin configuration: ${error}`);
+  _pluginService.pluginService.activatePlugin(id);
+  res.status(200).send(`Plugin "${id}" activated.`);
+};
+exports.activatePlugin = activatePlugin;
+const deactivatePlugin = (req, res) => {
+  const {
+    id
+  } = req.params;
+  const plugin = _pluginService.pluginService.getPlugins().find(p => p.id === id);
+  if (!plugin) {
+    res.status(404).send(`Plugin with id "${id}" not found.`);
     return;
   }
-  if (plugin.isConfigured()) {
-    _logger.default.info(`Loaded plugin <${plugin.getName()}>`);
-    pluginResource.pluginImplementation = plugin;
-    pluginResource.name = plugin.getName();
-    pluginResource.active = true;
-    _pluginService.pluginService.pushPlugin(pluginResource);
-    _pluginService.pluginService.activatePlugin(pluginResource);
-    res.status(201).send(`Plugin registered`);
-  } else {
-    _logger.default.error(`Plugin <${plugin.getName()}> cannot be configured`);
-    res.status(400).send(`Plugin configuration problem`);
+  _pluginService.pluginService.deactivatePlugin(id); // This only sets active to false
+  res.status(200).send(`Plugin "${id}" deactivated.`);
+};
+exports.deactivatePlugin = deactivatePlugin;
+const deletePlugin = (req, res) => {
+  const {
+    id
+  } = req.params;
+  const plugin = _pluginService.pluginService.getPlugins().find(p => p.id === id);
+  if (!plugin) {
+    res.status(404).send(`Plugin with id "${id}" not found.`);
+    return;
   }
+  _pluginService.pluginService.deletePlugin(id); // kills child inside service
+  res.status(200).send(`Plugin "${id}" deleted.`);
 };
-exports.registerPlugin = registerPlugin;
+exports.deletePlugin = deletePlugin;

package/dist/cjs/tlm-plugin/pluginProcess.cjs

@@ -0,0 +1,108 @@
+"use strict";
+
+var _importFromString = require("import-from-string");
+var _dynamicInstaller = require("dynamic-installer");
+// pluginProcess.js
+// Runs inside a child process, isolated from the main app
+// @ts-expect-error no types
+
+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 (0, _dynamicInstaller.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 (0, _importFromString.importFromString)(pluginResource.sourceCode);
+      } else {
+        module = await (0, _importFromString.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/cjs/tlm-plugin/pluginRoutes.cjs

@@ -10,6 +10,9 @@ const getPluginRoutes = () => {
   const router = (0, _express.Router)();
   router.get('/', _pluginController.listPlugins);
   router.post('/', _pluginController.registerPlugin);
+  router.post('/:id/activate', _pluginController.activatePlugin);
+  router.post('/:id/deactivate', _pluginController.deactivatePlugin);
+  router.delete('/:id', _pluginController.deletePlugin);
   return router;
 };
 exports.getPluginRoutes = getPluginRoutes;

package/dist/cjs/tlm-plugin/pluginService.cjs

@@ -4,6 +4,8 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.pluginService = void 0;
+var _logger = _interopRequireDefault(require("../utils/logger.cjs"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 class PluginService {
   constructor() {
     this.plugins = [];
@@ -14,12 +16,64 @@ class PluginService {
   pushPlugin(plugin) {
     this.plugins.push(plugin);
   }
-  activatePlugin(plugin) {
-    this.plugins.forEach(p => {
-      if (p.id === plugin.id) {
-        p.active = true;
+  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.default.debug(`Sent ${type} to child-process plugin <${plugin.name}> (#${i})`);
+          } catch (err) {
+            _logger.default.error(`Failed to send ${type} to plugin <${plugin.name}> (#${i}):`, err);
+          }
+        } else {
+          _logger.default.warn(`Plugin <${plugin.name}> (#${i}) is not connected. Skipping ${type}.`);
+        }
+      } else {
+        _logger.default.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);
+  }
 }
 const pluginService = exports.pluginService = new PluginService();

package/dist/esm/telemetry/custom-implementations/exporters/PluginLogExporter.js

@@ -17,16 +17,8 @@ export class PluginLogExporter extends Enabler {
             const cleanLogs = logs
                 .map(log => removeCircularRefs(log))
                 .map(log => applyNesting(log));
-            pluginService.getPlugins().forEach((pluginResource, i) => {
-                if (typeof pluginResource.pluginImplementation.newLog === 'function') {
-                    cleanLogs.forEach((log) => {
-                        logger.debug(`Sending log to plugin (Plugin #${i}) <${pluginResource.name}>`);
-                        pluginResource.pluginImplementation.newLog(log);
-                    });
-                }
-                else {
-                    logger.debug(`Plugin <${pluginResource.name}> does not implement newLog method. Skipping log export.`);
-                }
+            cleanLogs.forEach(log => {
+                pluginService.broadcastLog(log);
             });
             setTimeout(() => resultCallback({ code: ExportResultCode.SUCCESS }), 0);
         }

package/dist/esm/telemetry/custom-implementations/exporters/PluginMetricExporter.js

@@ -15,15 +15,7 @@ export class PluginMetricExporter extends Enabler {
                 return resultCallback({ code: ExportResultCode.SUCCESS });
             }
             const cleanMetrics = applyNesting(removeCircularRefs(metrics));
-            pluginService.getPlugins().forEach((pluginResource, i) => {
-                if (typeof pluginResource.pluginImplementation.newMetric === 'function') {
-                    logger.debug(`Sending metric to plugin (Plugin #${i}) <${pluginResource.name}>`);
-                    pluginResource.pluginImplementation.newMetric(cleanMetrics);
-                }
-                else {
-                    logger.debug(`Plugin <${pluginResource.name}> does not implement newMetric method. Skipping metric export.`);
-                }
-            });
+            pluginService.broadcastMetric(cleanMetrics);
             setTimeout(() => resultCallback({ code: ExportResultCode.SUCCESS }), 0);
         }
         catch (error) {

package/dist/esm/telemetry/custom-implementations/exporters/PluginSpanExporter.js

@@ -30,17 +30,8 @@ export class PluginSpanExporter extends Enabler {
                 }
                 return true;
             });
-            pluginService.getPlugins().forEach((pluginResource, i) => {
-                if (typeof pluginResource.pluginImplementation.newTrace === 'function') {
-                    cleanSpans.forEach((span) => {
-                        logger.debug(`Sending span to plugin (Plugin #${i}) <${pluginResource.name}>`);
-                        //TODO: This should be called newSpan instead of newTrace
-                        pluginResource.pluginImplementation.newTrace(span);
-                    });
-                }
-                else {
-                    logger.debug(`Plugin <${pluginResource.name}> does not implement newTrace method. Skipping span export.`);
-                }
+            cleanSpans.forEach(span => {
+                pluginService.broadcastTrace(span);
             });
             setTimeout(() => resultCallback({ code: ExportResultCode.SUCCESS }), 0);
         }