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

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,44 @@
+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));
+            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.`);
+                }
+            });
+            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,43 @@
+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.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.`);
+                }
+            });
+            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,61 @@
+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;
+            });
+            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.`);
+                }
+            });
+            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()));
+    }
+}

package/dist/esm/telemetry/custom-implementations/utils/circular.js

@@ -0,0 +1,76 @@
+export function removeCircularRefs(obj) {
+    // const seen = new WeakMap(); // Used to keep track of visited objects
+    // Replacer function to handle circular references
+    function replacer(key, value) {
+        if (key === "_spanProcessor") {
+            return "oas-telemetry skips this field to avoid circular reference";
+        }
+        // GENERIC CIRCULAR REFERENCE HANDLING
+        // if (typeof value === "object" && value !== null) {
+        //     // If the object has been visited before, return the name prefixed with "CIRCULAR+"
+        //     if (seen.has(value)) {
+        //         return `CIRCULAR${key}`;
+        //     }
+        //     seen.set(value, key); // Mark the object as visited with its name
+        // }
+        return value;
+    }
+    // Convert the object to a string and then parse it back
+    // This will trigger the replacer function to handle circular references
+    const jsonString = JSON.stringify(obj, replacer);
+    return JSON.parse(jsonString);
+}
+/**
+ * Recursively converts dot-separated keys in an object to nested objects.
+ *
+ * @param {any} obj - The object to process.
+ * @returns {any} - The object with all dot-separated keys converted to nested objects.
+ * @example
+ *  Input:
+ *  {
+ *    "http.method": "GET",
+ *    "http.url": "http://example.com",
+ *    "nested.obj.key": "value"
+ *  }
+ *  Output:
+ *  {
+ *    "http": {
+ *      "method": "GET",
+ *      "url": "http://example.com"
+ *    },
+ *    "nested": {
+ *      "obj": {
+ *        "key": "value"
+ *      }
+ *    }
+ *  }
+ */
+export function applyNesting(obj) {
+    if (Array.isArray(obj)) {
+        return obj.map(item => applyNesting(item));
+    }
+    else if (typeof obj === 'object' && obj !== null) {
+        const result = {};
+        for (const key in obj) {
+            const value = applyNesting(obj[key]);
+            const keys = key.split('.');
+            let temp = result;
+            for (let i = 0; i < keys.length; i++) {
+                const currentKey = keys[i];
+                if (i === keys.length - 1) {
+                    temp[currentKey] = value;
+                }
+                else {
+                    if (!temp[currentKey]) {
+                        temp[currentKey] = {};
+                    }
+                    temp = temp[currentKey];
+                }
+            }
+        }
+        return result;
+    }
+    else {
+        return obj;
+    }
+}