@oas-tools/oas-telemetry 0.7.1 → 0.8.0-alpha.1

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

@@ -7,9 +7,19 @@ import { Enabler } from '../wrappers.js';
 import logger from '../../../utils/logger.js';
 import { pluginService } from '../../../tlm-plugin/pluginService.js';
 export class InMemoryDbLogExporter extends Enabler {
+    _db = null;
+    _miniSearch = null;
+    _retentionTimeInSeconds;
+    _initialized = false;
     constructor(retentionTimeInSeconds = 3600) {
         super();
         this._retentionTimeInSeconds = retentionTimeInSeconds;
+        this._startCleanupJob();
+    }
+    _ensureInitialized() {
+        if (this._initialized)
+            return;
+        this._initialized = true;
         this._db = new Datastore({ timestampData: true });
         this._db.ensureIndex({ fieldName: 'createdAt' });
         this._miniSearch = new MiniSearch({
@@ -17,7 +27,7 @@ export class InMemoryDbLogExporter extends Enabler {
             storeFields: ['_id'],
             idField: '_id',
         });
-        this._startCleanupJob();
+        logger.info(`[LogExporter] In-memory storage created`);
     }
     /*
     * SUPER WARNING:
@@ -31,6 +41,7 @@ export class InMemoryDbLogExporter extends Enabler {
      * @param resultCallback
      */
     export(logs, resultCallback) {
+        this._ensureInitialized();
         const logsToInsert = logs.map(logRecord => {
             // Remove circular references first, then apply nesting, then export info
             const formattedLog = this._formatLogRecord(logRecord);
@@ -48,7 +59,17 @@ export class InMemoryDbLogExporter extends Enabler {
         resultCallback({ code: ExportResultCode.SUCCESS });
     }
     reset() {
-        this._db = new Datastore();
+        this._ensureInitialized();
+        // Remove all logs from the in-memory database.
+        this._db.remove({}, { multi: true }, (err) => {
+            if (err) {
+                logger.error(`[LogExporter] Error during reset: ${err.message}`);
+            }
+            else {
+                logger.info(`[LogExporter] Reset - all logs cleared`);
+            }
+        });
+        // Clear mini search index
         this._miniSearch = new MiniSearch({
             fields: ['body'],
             storeFields: ['_id'],
@@ -61,8 +82,10 @@ export class InMemoryDbLogExporter extends Enabler {
     async shutdown() {
         this._db = null;
         this._miniSearch = null;
+        this._initialized = false;
     }
     async find(findConfig) {
+        this._ensureInitialized();
         const { query, messageSearch, limit, sortOrder } = findConfig;
         const finalQuery = { ...query };
         const effectiveSortOrder = sortOrder || { timestamp: -1 };
@@ -73,10 +96,13 @@ export class InMemoryDbLogExporter extends Enabler {
             finalQuery._id = { $in: ids };
         }
         const docs = await new Promise((resolve, reject) => {
-            this._db.find(finalQuery)
-                .sort(effectiveSortOrder)
-                .limit(limit)
-                .exec((err, docs) => {
+            let query_exec = this._db.find(finalQuery)
+                .sort(effectiveSortOrder);
+            // Only apply limit if provided
+            if (limit !== undefined) {
+                query_exec = query_exec.limit(limit);
+            }
+            query_exec.exec((err, docs) => {
                 if (err)
                     reject(err);
                 else
@@ -103,6 +129,7 @@ export class InMemoryDbLogExporter extends Enabler {
         });
     }
     getFinishedLogs() {
+        this._ensureInitialized();
         return this._db.getAllData();
     }
     /**
@@ -136,6 +163,8 @@ export class InMemoryDbLogExporter extends Enabler {
         return this._retentionTimeInSeconds;
     }
     _insertLogs(logsToInsert, resultCallback) {
+        if (!this._db)
+            return resultCallback({ code: ExportResultCode.FAILED });
         this._db.insert(logsToInsert, (err, newDocs) => {
             if (err) {
                 console.dir(err);
@@ -143,7 +172,7 @@ export class InMemoryDbLogExporter extends Enabler {
                 return;
             }
             // console.dir(newDocs, { depth: 3 });
-            newDocs.forEach((doc) => this._miniSearch.add(doc));
+            newDocs.forEach((doc) => this._miniSearch?.add(doc));
             resultCallback({ code: ExportResultCode.SUCCESS });
         });
         return;
@@ -151,6 +180,8 @@ export class InMemoryDbLogExporter extends Enabler {
     _startCleanupJob() {
         const interval = 1000;
         setInterval(() => {
+            if (!this._db)
+                return; // Safety check
             const expirationDate = new Date(Date.now() - this._retentionTimeInSeconds * 1000);
             this._db.remove({ createdAt: { $lt: expirationDate } }, { multi: true }, (err, numRemoved) => {
                 if (err) {

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

@@ -1,32 +1,55 @@
 import { ExportResultCode } from '@opentelemetry/core';
-import dataStore from '@seald-io/nedb';
-import { applyNesting } from '../utils/circular.js';
 import { Enabler } from '../wrappers.js';
 import logger from '../../../utils/logger.js';
 import { pluginService } from '../../../tlm-plugin/pluginService.js';
+import { rawToOtel } from '../metrics/tsdb/utils.js';
+import { SeriesRegistry } from '../metrics/tsdb/SeriesRegistry.js';
+/**
+ * In-Memory TSDB Metric Exporter
+ * Series identified by: scope + metricName + attributes
+ */
 export class InMemoryDbMetricExporter extends Enabler {
-    constructor(retentionTimeInSeconds = 3600) {
+    static DEFAULT_CONFIG = {
+        retentionTimeInSeconds: 3600,
+        chunkSize: 120,
+        maxChunks: 60
+    };
+    registry;
+    config;
+    cachedResource = null;
+    _initialized = false;
+    _ensureInitialized() {
+        if (this._initialized)
+            return;
+        this._initialized = true;
+        logger.info(`[MetricExporter] In-memory storage created`);
+    }
+    get rawDataDB() {
+        // For debug/inspection only - metrics are stored in registry chunks
+        const stats = this.registry.getStats();
+        return stats.totalSamples > 0 ? [`[${stats.totalSamples} samples in registry]`] : [];
+    }
+    constructor(config) {
         super();
-        this._retentionTimeInSeconds = retentionTimeInSeconds;
-        this._metrics = new dataStore({ timestampData: true });
-        this._metrics.ensureIndex({ fieldName: 'createdAt' });
+        this.config = { ...InMemoryDbMetricExporter.DEFAULT_CONFIG, ...config };
+        this.registry = new SeriesRegistry(this.config.chunkSize, this.config.maxChunks);
         this._startCleanupJob();
     }
-    export(metrics, resultCallback) {
+    export(resourceMetrics, resultCallback) {
+        this._ensureInitialized();
         try {
-            const scopeMetrics = metrics?.scopeMetrics;
-            const cleanMetrics = applyNesting(scopeMetrics);
-            cleanMetrics.forEach((metric) => {
+            // Cache resource (unique per exporter instance)
+            if (!this.cachedResource) {
+                this.cachedResource = resourceMetrics.resource;
+            }
+            const scopeMetrics = resourceMetrics.scopeMetrics;
+            // Broadcast to plugins
+            scopeMetrics?.forEach((metric) => {
                 pluginService.broadcastMetric(metric);
             });
-            // Insert only if exporter is enabled
-            if (this.isEnabled()) {
-                this._metrics.insert(cleanMetrics, (err, _newDoc) => {
-                    if (err) {
-                        logger.error('Insertion Error:', err);
-                        return;
-                    }
-                });
+            // Store if enabled - use new storeScopeMetrics method
+            if (this.isEnabled() && scopeMetrics) {
+                this.registry.storeScopeMetrics(scopeMetrics);
             }
             setTimeout(() => resultCallback({ code: ExportResultCode.SUCCESS }), 0);
         }
@@ -40,48 +63,84 @@ export class InMemoryDbMetricExporter extends Enabler {
     }
     shutdown() {
         this._enabled = false;
-        this._metrics = new dataStore();
+        this.registry.reset();
         return this.forceFlush();
     }
+    reset() {
+        this._ensureInitialized();
+        this.registry.reset();
+        logger.info(`[MetricExporter] Reset - all metrics cleared`);
+    }
     forceFlush() {
         return Promise.resolve();
     }
-    find(search, callback) {
-        this._metrics.find(search, callback);
+    getCachedResource() {
+        return this.cachedResource;
     }
-    reset() {
-        this._metrics = new dataStore();
+    set retentionTimeInSeconds(value) {
+        this.config.retentionTimeInSeconds = value;
+        logger.info(`Retention time set to ${value} seconds`);
+    }
+    get retentionTimeInSeconds() {
+        return this.config.retentionTimeInSeconds;
+    }
+    getStats() {
+        this._ensureInitialized();
+        return this.registry.getStats();
+    }
+    _startCleanupJob() {
+        setInterval(() => {
+            const retentionTimeNs = this.config.retentionTimeInSeconds * 1_000_000_000;
+            const result = this.registry.evictOldData(retentionTimeNs);
+            if (result.evictedChunks > 0 || result.evictedSeries > 0) {
+                logger.debug(`Cleanup: evicted ${result.evictedChunks} chunks, ${result.evictedSeries} series`);
+            }
+        }, 5000);
     }
-    getFinishedMetrics() {
-        return this._metrics.getAllData();
+    /**
+     * Find metrics by scope+metric queries with filters
+     * Supports both raw and otel formats
+     */
+    find(request) {
+        this._ensureInitialized();
+        const format = request.format || 'raw';
+        // Get raw results from registry using new unified query method
+        const rawResults = this.registry.query(request.scopeMetrics, request.from, request.to);
+        // Convert format if needed
+        if (format === 'otel') {
+            return { results: rawToOtel(rawResults) };
+        }
+        return { results: rawResults };
     }
     /**
-     * Inserts metrics into the in-memory database.
-     * @param metrics - The metrics to insert.
-     * @param callback - The callback to execute after insertion.
+     * Export all metrics as line-delimited JSON (one chunk per line)
      */
-    insert(metrics, callback) {
-        this._metrics.insert(metrics, callback);
+    exportToLineDelimitedJson() {
+        return this.registry.serializeToLineDelimitedJson();
     }
-    set retentionTimeInSeconds(retentionTimeInSeconds) {
-        this._retentionTimeInSeconds = retentionTimeInSeconds;
-        logger.info(`InMemoryDbMetricExporter retention time set to ${this._retentionTimeInSeconds} seconds`);
+    /**
+     * Import metrics from line-delimited JSON format
+     */
+    importFromLineDelimitedJson(lineDelimitedJsonData) {
+        this.registry.deserializeFromLineDelimitedJson(lineDelimitedJsonData);
     }
-    get retentionTimeInSeconds() {
-        return this._retentionTimeInSeconds;
+    /**
+ * Insert metrics in OpenTelemetry (OTEL) format directly into the registry
+ * @param scopeMetrics Array of ScopeMetrics (OTEL format)
+ */
+    insertOtel(scopeMetrics) {
+        this._ensureInitialized();
+        // Store only in registry (chunks) - no duplication
+        if (this.isEnabled()) {
+            this.registry.storeScopeMetrics(scopeMetrics);
+        }
     }
-    _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);
+    /**
+     * Insert metrics in raw format (MetricQueryResult[]), converts to OTEL and delegates to insertOtel
+     * @param rawScopeMetrics Array of MetricQueryResult (raw format)
+     */
+    insertRaw(rawScopeMetrics) {
+        const otelScopeMetrics = rawToOtel(rawScopeMetrics);
+        this.insertOtel(otelScopeMetrics);
     }
 }

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

@@ -5,17 +5,22 @@ import { applyNesting, removeCircularRefs } from '../utils/circular.js';
 import { Enabler } from '../wrappers.js';
 import { pluginService } from '../../../tlm-plugin/pluginService.js';
 export class InMemoryDbSpanExporter extends Enabler {
+    _spans = null;
+    _retentionTimeInSeconds;
+    _initialized = false;
     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;
+    _ensureInitialized() {
+        if (this._initialized)
+            return;
+        this._initialized = true;
+        this._spans = new dataStore({ timestampData: true });
+        this._spans.ensureIndex({ fieldName: 'createdAt' });
+        logger.info(`[SpanExporter] In-memory storage created`);
     }
     set retentionTimeInSeconds(retentionTimeInSeconds) {
         this._retentionTimeInSeconds = retentionTimeInSeconds;
@@ -25,32 +30,26 @@ export class InMemoryDbSpanExporter extends Enabler {
         return this._retentionTimeInSeconds;
     }
     export(readableSpans, resultCallback) {
+        this._ensureInitialized();
         logger.debug('InMemoryDbSpanExporter.export called with spans: ', readableSpans.length);
         try {
             // 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/generate-log' or 'telemetry/utils/generate-wait'
-                if (target && target.includes(this._baseUrl)) {
-                    return (target.includes("generate"));
-                }
-                return true;
-            });
+                .map(span => applyNesting(span)); // to avoid dot notation in keys (neDB does not support dot notation in keys)
             cleanSpans.forEach(span => {
                 pluginService.broadcastTrace(span);
             });
-            // 
             if (this.isEnabled()) {
                 // Insert spans into the in-memory database
-                this._spans.insert(cleanSpans, (err, _newDoc) => {
-                    if (err) {
-                        logger.error(err);
-                        return;
-                    }
-                });
+                if (this._spans) {
+                    this._spans.insert(cleanSpans, (err, _newDoc) => {
+                        if (err) {
+                            logger.error(err);
+                            return;
+                        }
+                    });
+                }
             }
             return resultCallback({ code: ExportResultCode.SUCCESS });
         }
@@ -64,10 +63,21 @@ export class InMemoryDbSpanExporter extends Enabler {
     }
     ;
     shutdown() {
-        this._spans = new dataStore();
+        this._spans = null;
         return this.forceFlush();
     }
     ;
+    reset() {
+        this._ensureInitialized();
+        this._spans.remove({}, { multi: true }, (err) => {
+            if (err) {
+                logger.error(`[SpanExporter] Error during reset: ${err.message}`);
+            }
+            else {
+                logger.info(`[SpanExporter] Reset - all spans cleared`);
+            }
+        });
+    }
     /**
      * Exports any pending spans in the exporter
      */
@@ -75,15 +85,30 @@ export class InMemoryDbSpanExporter extends Enabler {
         return Promise.resolve();
     }
     ;
-    //err,docs
-    find(search, callback) {
-        this._spans.find(search, callback);
-    }
-    reset() {
-        this._spans = new dataStore();
+    async find(findConfig) {
+        this._ensureInitialized();
+        const { query, limit, sortOrder } = findConfig;
+        const effectiveSortOrder = sortOrder || { timestamp: -1 };
+        const docs = await new Promise((resolve, reject) => {
+            let query_exec = this._spans.find(query)
+                .sort(effectiveSortOrder);
+            // Only apply limit if provided
+            if (limit !== undefined) {
+                query_exec = query_exec.limit(limit);
+            }
+            query_exec.exec((err, docs) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve(docs);
+            });
+        });
+        return docs;
     }
-    ;
     getFinishedSpans() {
+        this._ensureInitialized();
+        if (!this._spans)
+            return [];
         return this._spans.getAllData();
     }
     ;
@@ -93,11 +118,17 @@ export class InMemoryDbSpanExporter extends Enabler {
      * @param callback - The callback to execute after insertion.
      */
     insert(spans, callback) {
+        this._ensureInitialized();
+        if (!this._spans) {
+            return callback(new Error('Spans database not initialized'), []);
+        }
         this._spans.insert(spans, callback);
     }
     _startCleanupJob() {
         const interval = 1000;
         setInterval(() => {
+            if (!this._spans)
+                return; // Safety check - not initialized yet
             const expirationDate = new Date(Date.now() - this._retentionTimeInSeconds * 1000);
             this._spans.remove({ createdAt: { $lt: expirationDate } }, { multi: true }, (err, numRemoved) => {
                 if (err) {

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

@@ -0,0 +1,53 @@
+import { ExportResultCode } from '@opentelemetry/core';
+export class MultiMetricExporter {
+    exporters;
+    constructor(exporters) {
+        this.exporters = exporters;
+    }
+    export(resourceMetrics, resultCallback) {
+        if (!this.exporters.length) {
+            resultCallback({ code: ExportResultCode.SUCCESS });
+            return;
+        }
+        let pending = this.exporters.length;
+        let failed = false;
+        let firstError;
+        this.exporters.forEach((exporter) => {
+            try {
+                exporter.export(resourceMetrics, (result) => {
+                    if (result.code === ExportResultCode.FAILED) {
+                        failed = true;
+                        if (result.error && !firstError) {
+                            firstError = result.error;
+                        }
+                    }
+                    pending -= 1;
+                    if (pending === 0) {
+                        resultCallback(failed
+                            ? { code: ExportResultCode.FAILED, error: firstError }
+                            : { code: ExportResultCode.SUCCESS });
+                    }
+                });
+            }
+            catch (error) {
+                failed = true;
+                if (!firstError) {
+                    firstError = error instanceof Error ? error : new Error(String(error));
+                }
+                pending -= 1;
+                if (pending === 0) {
+                    resultCallback({ code: ExportResultCode.FAILED, error: firstError });
+                }
+            }
+        });
+    }
+    async shutdown() {
+        await Promise.all(this.exporters.map((exporter) => exporter.shutdown()));
+    }
+    async forceFlush() {
+        await Promise.all(this.exporters
+            .map((exporter) => exporter.forceFlush)
+            .filter((forceFlush) => typeof forceFlush === 'function')
+            .map((forceFlush) => forceFlush()));
+    }
+}

package/dist/esm/telemetry/custom-implementations/instrumentations/logsInstrumentation.js

@@ -0,0 +1,85 @@
+import { InstrumentationBase } from '@opentelemetry/instrumentation';
+import { SeverityNumber } from '@opentelemetry/api-logs';
+import util from 'util';
+import { originalConsoleMethods } from '../../telemetryRegistry.js';
+export class LogsInstrumentation extends InstrumentationBase {
+    _loggerProvider;
+    _otelLogger;
+    constructor(config = {}) {
+        super('@oas-telemetry/logs-instrumentation', '1.0.0', config);
+    }
+    /**
+     * No-op: this instrumentation does not patch modules loaded via require().
+     */
+    init() {
+        return [];
+    }
+    /**
+     * Called by the SDK when the LoggerProvider is available.
+     * This is the correct way for an instrumentation to receive a logger provider.
+     */
+    setLoggerProvider(provider) {
+        this._loggerProvider = provider;
+        this._otelLogger = provider.getLogger(this.instrumentationName);
+        // If already enabled, re-apply patches with the new logger provider.
+        if (this.isEnabled()) {
+            this._unpatchConsole();
+            this._patchConsole();
+        }
+    }
+    /**
+     * Called by the SDK after all providers have been registered.
+     */
+    enable() {
+        super.enable();
+        // Fallback: if no logger provider has been set yet, we do nothing.
+        if (!this._loggerProvider) {
+            return;
+        }
+        this._patchConsole();
+    }
+    disable() {
+        super.disable();
+        this._unpatchConsole();
+    }
+    _patchConsole() {
+        if (!this._otelLogger)
+            return;
+        Object.keys(originalConsoleMethods).forEach((method) => {
+            const original = originalConsoleMethods[method];
+            console[method] = (...args) => {
+                const { number, text } = getSeverityForMethod(method);
+                this._otelLogger.emit({
+                    severityNumber: number,
+                    severityText: text,
+                    body: util.format(...args),
+                    attributes: {
+                        source: `console.${method}`,
+                        library: this.instrumentationName,
+                    },
+                });
+                original(...args);
+            };
+        });
+    }
+    _unpatchConsole() {
+        Object.keys(originalConsoleMethods).forEach((method) => {
+            console[method] = originalConsoleMethods[method];
+        });
+    }
+}
+function getSeverityForMethod(method) {
+    switch (method) {
+        case "log":
+        case "info":
+            return { number: SeverityNumber.INFO, text: "INFO" };
+        case "debug":
+            return { number: SeverityNumber.DEBUG, text: "DEBUG" };
+        case "warn":
+            return { number: SeverityNumber.WARN, text: "WARN" };
+        case "error":
+            return { number: SeverityNumber.ERROR, text: "ERROR" };
+        default:
+            return { number: SeverityNumber.INFO, text: "INFO" };
+    }
+}