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

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);
+    }
 }

package/dist/esm/{exporters/InMemoryDBMetricsExporter.js → telemetry/custom-implementations/exporters/InMemoryDbMetricExporter.js}

@@ -1,19 +1,24 @@
 import { ExportResultCode } from '@opentelemetry/core';
 import dataStore from '@seald-io/nedb';
 import { applyNesting } from '../utils/circular.js';
-export class InMemoryDBMetricsExporter {
-    constructor() {
-        this._metrics = new dataStore();
-        this._stopped = false;
+import { Enabler } from '../wrappers.js';
+import logger from '../../../utils/logger.js';
+export class InMemoryDbMetricExporter extends Enabler {
+    constructor(retentionTimeInSeconds = 3600) {
+        super();
+        this._retentionTimeInSeconds = retentionTimeInSeconds;
+        this._metrics = new dataStore({ timestampData: true });
+        this._metrics.ensureIndex({ fieldName: 'createdAt' });
+        this._startCleanupJob();
     }
     export(metrics, resultCallback) {
         try {
-            if (!this._stopped) {
+            if (this.isEnabled()) {
                 const scopeMetrics = metrics?.scopeMetrics;
                 const cleanMetrics = applyNesting(scopeMetrics);
                 this._metrics.insert(cleanMetrics, (err, _newDoc) => {
                     if (err) {
-                        console.error('Insertion Error:', err);
+                        logger.error('Insertion Error:', err);
                         return;
                     }
                 });
@@ -21,24 +26,15 @@ export class InMemoryDBMetricsExporter {
             setTimeout(() => resultCallback({ code: ExportResultCode.SUCCESS }), 0);
         }
         catch (error) {
-            console.error('Error exporting metrics\n' + error.message + '\n' + error.stack);
+            logger.error('Error exporting metrics\n' + error.message + '\n' + error.stack);
             return resultCallback({
                 code: ExportResultCode.FAILED,
                 error: new Error('Error exporting metrics\n' + error.message + '\n' + error.stack),
             });
         }
     }
-    start() {
-        this._stopped = false;
-    }
-    stop() {
-        this._stopped = true;
-    }
-    isRunning() {
-        return !this._stopped;
-    }
     shutdown() {
-        this._stopped = true;
+        this._enabled = false;
         this._metrics = new dataStore();
         return this.forceFlush();
     }
@@ -62,4 +58,22 @@ export class InMemoryDBMetricsExporter {
     insert(metrics, callback) {
         this._metrics.insert(metrics, callback);
     }
+    set retentionTimeInSeconds(retentionTimeInSeconds) {
+        this._retentionTimeInSeconds = retentionTimeInSeconds;
+        logger.info(`InMemoryDbMetricExporter retention time set to ${this._retentionTimeInSeconds} seconds`);
+    }
+    _startCleanupJob() {
+        const interval = 1000;
+        setInterval(() => {
+            const expirationDate = new Date(Date.now() - this._retentionTimeInSeconds * 1000);
+            this._metrics.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 metrics`);
+                }
+            });
+        }, interval);
+    }
 }

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

@@ -0,0 +1,105 @@
+import { ExportResultCode } from '@opentelemetry/core';
+import dataStore from '@seald-io/nedb';
+import logger from '../../../utils/logger.js';
+import { applyNesting, removeCircularRefs } from '../utils/circular.js';
+import { Enabler } from '../wrappers.js';
+export class InMemoryDbSpanExporter extends Enabler {
+    constructor(retentionTimeInSeconds = 3600) {
+        super();
+        this._baseUrl = '/telemetry'; // Default base URL, can be overridden by the config
+        this._retentionTimeInSeconds = retentionTimeInSeconds;
+        this._spans = new dataStore({ timestampData: true });
+        this._spans.ensureIndex({ fieldName: 'createdAt' });
+        this._startCleanupJob();
+    }
+    ;
+    set baseUrl(baseUrl) {
+        this._baseUrl = baseUrl;
+    }
+    set retentionTimeInSeconds(retentionTimeInSeconds) {
+        this._retentionTimeInSeconds = retentionTimeInSeconds;
+        logger.info(`InMemoryDbSpanExporter retention time set to ${this._retentionTimeInSeconds} seconds`);
+    }
+    export(readableSpans, resultCallback) {
+        logger.debug('InMemoryDbSpanExporter.export called with spans: ', readableSpans.length);
+        try {
+            if (!this.isEnabled()) {
+                logger.debug('InMemoryDbSpanExporter is not enabled. Skipping export.');
+                return resultCallback({ code: ExportResultCode.SUCCESS });
+            }
+            // Prepare spans to be inserted into the in-memory database (remove circular references and convert to nested objects)
+            const cleanSpans = readableSpans
+                .map(nestedSpan => removeCircularRefs(nestedSpan)) // to avoid JSON parsing error
+                .map(span => applyNesting(span)) // to avoid dot notation in keys (neDB does not support dot notation in keys)
+                .filter(span => {
+                const target = span?.attributes?.http?.target; // Exclude spans where target includes 'telemetry' but NOT 'telemetry/utils'
+                if (target && target.includes(this._baseUrl)) {
+                    return target.includes(this._baseUrl + '/utils');
+                }
+                return true;
+            });
+            // Insert spans into the in-memory database
+            this._spans.insert(cleanSpans, (err, _newDoc) => {
+                if (err) {
+                    logger.error(err);
+                    return;
+                }
+            });
+            setTimeout(() => resultCallback({ code: ExportResultCode.SUCCESS }), 0);
+        }
+        catch (error) {
+            logger.error('Error exporting spans\n' + error.message + '\n' + error.stack);
+            return resultCallback({
+                code: ExportResultCode.FAILED,
+                error: new Error('Error exporting spans\n' + error.message + '\n' + error.stack),
+            });
+        }
+    }
+    ;
+    shutdown() {
+        this._spans = new dataStore();
+        return this.forceFlush();
+    }
+    ;
+    /**
+     * Exports any pending spans in the exporter
+     */
+    forceFlush() {
+        return Promise.resolve();
+    }
+    ;
+    //err,docs
+    find(search, callback) {
+        this._spans.find(search, callback);
+    }
+    reset() {
+        this._spans = new dataStore();
+    }
+    ;
+    getFinishedSpans() {
+        return this._spans.getAllData();
+    }
+    ;
+    /**
+     * Inserts spans into the in-memory database.
+     * @param spans - The spans to insert.
+     * @param callback - The callback to execute after insertion.
+     */
+    insert(spans, callback) {
+        this._spans.insert(spans, callback);
+    }
+    _startCleanupJob() {
+        const interval = 1000;
+        setInterval(() => {
+            const expirationDate = new Date(Date.now() - this._retentionTimeInSeconds * 1000);
+            this._spans.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 spans`);
+                }
+            });
+        }, interval);
+    }
+}

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

@@ -0,0 +1,36 @@
+import { ExportResultCode } from '@opentelemetry/core';
+import logger from '../../../utils/logger.js';
+import { Enabler } from '../wrappers.js';
+import { pluginService } from '../../../tlm-plugin/pluginService.js';
+import { applyNesting, removeCircularRefs } from '../utils/circular.js';
+export class PluginLogExporter extends Enabler {
+    constructor() {
+        super();
+    }
+    export(logs, resultCallback) {
+        logger.debug('PluginLogExporter.export called with logs: ', logs.length);
+        try {
+            if (!this.isEnabled()) {
+                logger.debug('PluginLogExporter is not enabled. Skipping export.');
+                return resultCallback({ code: ExportResultCode.SUCCESS });
+            }
+            const cleanLogs = logs
+                .map(log => removeCircularRefs(log))
+                .map(log => applyNesting(log));
+            cleanLogs.forEach(log => {
+                pluginService.broadcastLog(log);
+            });
+            setTimeout(() => resultCallback({ code: ExportResultCode.SUCCESS }), 0);
+        }
+        catch (error) {
+            logger.error('Error exporting logs\n' + error.message + '\n' + error.stack);
+            return resultCallback({
+                code: ExportResultCode.FAILED,
+                error: new Error('Error exporting logs\n' + error.message + '\n' + error.stack),
+            });
+        }
+    }
+    shutdown() {
+        return Promise.resolve();
+    }
+}

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

@@ -0,0 +1,35 @@
+import { ExportResultCode } from '@opentelemetry/core';
+import logger from '../../../utils/logger.js';
+import { Enabler } from '../wrappers.js';
+import { pluginService } from '../../../tlm-plugin/pluginService.js';
+import { applyNesting, removeCircularRefs } from '../utils/circular.js';
+export class PluginMetricExporter extends Enabler {
+    constructor() {
+        super();
+    }
+    export(metrics, resultCallback) {
+        logger.debug('PluginMetricExporter.export called');
+        try {
+            if (!this.isEnabled()) {
+                logger.debug('PluginMetricExporter is not enabled. Skipping export.');
+                return resultCallback({ code: ExportResultCode.SUCCESS });
+            }
+            const cleanMetrics = applyNesting(removeCircularRefs(metrics));
+            pluginService.broadcastMetric(cleanMetrics);
+            setTimeout(() => resultCallback({ code: ExportResultCode.SUCCESS }), 0);
+        }
+        catch (error) {
+            logger.error('Error exporting metrics\n' + error.message + '\n' + error.stack);
+            return resultCallback({
+                code: ExportResultCode.FAILED,
+                error: new Error('Error exporting metrics\n' + error.message + '\n' + error.stack),
+            });
+        }
+    }
+    shutdown() {
+        return Promise.resolve();
+    }
+    forceFlush() {
+        return Promise.resolve();
+    }
+}

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

@@ -0,0 +1,52 @@
+import { ExportResultCode } from '@opentelemetry/core';
+import logger from '../../../utils/logger.js';
+import { Enabler } from '../wrappers.js';
+import { pluginService } from '../../../tlm-plugin/pluginService.js';
+import { applyNesting, removeCircularRefs } from '../utils/circular.js';
+export class PluginSpanExporter extends Enabler {
+    constructor() {
+        super();
+        this._baseUrl = '/telemetry'; // Default base URL, can be overridden by the config
+    }
+    ;
+    set baseUrl(baseUrl) {
+        this._baseUrl = baseUrl;
+    }
+    export(readableSpans, resultCallback) {
+        logger.debug('PluginSpanExporter.export called with spans: ', readableSpans.length);
+        try {
+            if (!this.isEnabled()) {
+                logger.debug('PluginSpanExporter is not enabled. Skipping export.');
+                return resultCallback({ code: ExportResultCode.SUCCESS });
+            }
+            // Prepare spans to be inserted into the in-memory database (remove circular references and convert to nested objects)
+            const cleanSpans = readableSpans
+                .map(nestedSpan => removeCircularRefs(nestedSpan)) // to avoid JSON parsing error
+                .map(span => applyNesting(span)) // to avoid dot notation in keys (neDB does not support dot notation in keys)
+                .filter(span => {
+                const target = span?.attributes?.http?.target; // Exclude spans where target includes 'telemetry' but NOT 'telemetry/utils'
+                if (target && target.includes(this._baseUrl)) {
+                    return target.includes(this._baseUrl + '/utils');
+                }
+                return true;
+            });
+            cleanSpans.forEach(span => {
+                pluginService.broadcastTrace(span);
+            });
+            setTimeout(() => resultCallback({ code: ExportResultCode.SUCCESS }), 0);
+        }
+        catch (error) {
+            logger.error('Error exporting spans\n' + error.message + '\n' + error.stack);
+            return resultCallback({
+                code: ExportResultCode.FAILED,
+                error: new Error('Error exporting spans\n' + error.message + '\n' + error.stack),
+            });
+        }
+    }
+    shutdown() {
+        return this.forceFlush();
+    }
+    forceFlush() {
+        return Promise.resolve();
+    }
+}

package/dist/esm/telemetry/custom-implementations/processors/dynamicMultiLogProcessor.js

@@ -0,0 +1,64 @@
+import { callWithTimeout } from '@opentelemetry/core';
+import logger from '../../../utils/logger.js'; // optional if you want logging
+export class DynamicMultiLogRecordProcessor {
+    constructor(initialProcessors = [], forceFlushTimeoutMillis = 30000) {
+        this._processors = [];
+        this._processors = [...initialProcessors];
+        this._forceFlushTimeoutMillis = forceFlushTimeoutMillis;
+    }
+    /**
+     * Add a new LogRecordProcessor or an array of LogRecordProcessors at runtime.
+     */
+    addProcessors(processor) {
+        if (Array.isArray(processor)) {
+            this._processors.push(...processor);
+        }
+        else {
+            this._processors.push(processor);
+        }
+    }
+    /**
+     * Remove a specific LogRecordProcessor.
+     */
+    removeProcessor(processor) {
+        this._processors = this._processors.filter(p => p !== processor);
+    }
+    /**
+     * Clear all LogRecordProcessors.
+     */
+    clearProcessors() {
+        this._processors = [];
+    }
+    /**
+     * Called when a log record is emitted.
+     */
+    onEmit(logRecord, context) {
+        for (const processor of this._processors) {
+            try {
+                processor.onEmit(logRecord, context);
+            }
+            catch (error) {
+                logger?.error?.('Error in onEmit of LogRecordProcessor:', error);
+            }
+        }
+    }
+    /**
+     * Force flush all processors with timeout.
+     */
+    async forceFlush() {
+        const timeout = this._forceFlushTimeoutMillis;
+        const promises = this._processors.map(p => callWithTimeout(p.forceFlush(), timeout));
+        try {
+            await Promise.all(promises);
+        }
+        catch (error) {
+            logger?.error?.('Error during forceFlush in DynamicMultiLogRecordProcessor:', error);
+        }
+    }
+    /**
+     * Shutdown all processors.
+     */
+    async shutdown() {
+        await Promise.all(this._processors.map(p => p.shutdown()));
+    }
+}

package/dist/esm/telemetry/custom-implementations/processors/dynamicMultiSpanProcessor.js

@@ -0,0 +1,64 @@
+import logger from '../../../utils/logger.js';
+export class DynamicMultiSpanProcessor {
+    constructor(initialProcessors = []) {
+        this._spanProcessors = [];
+        this._spanProcessors = [...initialProcessors];
+    }
+    /**
+     * Add a new SpanProcessor or an array of SpanProcessors at runtime.
+     */
+    addProcessors(processor) {
+        if (Array.isArray(processor)) {
+            this._spanProcessors.push(...processor);
+        }
+        else {
+            this._spanProcessors.push(processor);
+        }
+    }
+    /**
+     * Remove a specific SpanProcessor if needed.
+     */
+    removeProcessor(processor) {
+        this._spanProcessors = this._spanProcessors.filter(p => p !== processor);
+    }
+    /**
+     * Clear all processors.
+     */
+    clearProcessors() {
+        this._spanProcessors = [];
+    }
+    /**
+     * Called when a span is started.
+     */
+    onStart(span, context) {
+        for (const processor of this._spanProcessors) {
+            processor.onStart(span, context);
+        }
+    }
+    /**
+     * Called when a span ends.
+     */
+    onEnd(span) {
+        for (const processor of this._spanProcessors) {
+            processor.onEnd(span);
+        }
+    }
+    /**
+     * Force flush all processors.
+     */
+    async forceFlush() {
+        const promises = this._spanProcessors.map(p => p.forceFlush());
+        try {
+            await Promise.all(promises);
+        }
+        catch (error) {
+            logger.error('Error during forceFlush:', error);
+        }
+    }
+    /**
+     * Shutdown all processors.
+     */
+    async shutdown() {
+        await Promise.all(this._spanProcessors.map(p => p.shutdown()));
+    }
+}