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

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

@@ -4,18 +4,31 @@ import logger from '../../../utils/logger.js';
 import { applyNesting, removeCircularRefs } from '../utils/circular.js';
 import { Enabler } from '../wrappers.js';
 import { pluginService } from '../../../tlm-plugin/pluginService.js';
+import { getStoragePath } from '../utils/storagePath.js';
 export class InMemoryDbSpanExporter extends Enabler {
+    _spans = null;
+    _retentionTimeInSeconds;
+    _storagePath = null;
+    _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._storagePath = getStoragePath('traces');
         this._startCleanupJob();
     }
     ;
-    set baseUrl(baseUrl) {
-        this._baseUrl = baseUrl;
+    _ensureInitialized() {
+        if (this._initialized)
+            return;
+        this._initialized = true;
+        this._spans = new dataStore(this._storagePath ? { filename: this._storagePath, timestampData: true, autoload: true } : { timestampData: true });
+        this._spans.ensureIndex({ fieldName: 'createdAt' });
+        if (this._storagePath) {
+            logger.info(`[SpanExporter] Disk storage enabled at: ${this._storagePath}`);
+        }
+        else {
+            logger.info(`[SpanExporter] Using in-memory storage`);
+        }
     }
     set retentionTimeInSeconds(retentionTimeInSeconds) {
         this._retentionTimeInSeconds = retentionTimeInSeconds;
@@ -25,32 +38,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 +71,22 @@ export class InMemoryDbSpanExporter extends Enabler {
     }
     ;
     shutdown() {
-        this._spans = new dataStore();
+        this._spans = null;
         return this.forceFlush();
     }
     ;
+    reset() {
+        this._ensureInitialized();
+        // Remove all spans from database but keep persistence enabled
+        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 +94,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 +127,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/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" };
+    }
+}

package/dist/esm/telemetry/custom-implementations/metrics/tsdb/Chunk.js

@@ -0,0 +1,155 @@
+export class Chunk {
+    maxSamples;
+    startTimes;
+    endTimes;
+    values;
+    histograms;
+    cursor = 0;
+    minEndTime = 0;
+    maxEndTime = 0;
+    isHistogram;
+    constructor(maxSamples = 120, isHistogram = false) {
+        this.maxSamples = maxSamples;
+        this.startTimes = new Float64Array(maxSamples);
+        this.endTimes = new Float64Array(maxSamples);
+        this.values = new Float64Array(maxSamples);
+        this.histograms = new Array(maxSamples).fill(null);
+        this.isHistogram = isHistogram;
+    }
+    /**
+     * Append a sample to the chunk.
+     * Returns true if successful or false if the chunk is full.
+     */
+    append(startTime, endTime, value) {
+        if (this.cursor >= this.maxSamples) {
+            return false;
+        }
+        if (this.cursor === 0) {
+            this.minEndTime = endTime;
+        }
+        this.startTimes[this.cursor] = startTime;
+        this.endTimes[this.cursor] = endTime;
+        if (this.isHistogram && typeof value === 'object') {
+            this.values[this.cursor] = value.count;
+            this.histograms[this.cursor] = value;
+        }
+        else if (typeof value === 'number') {
+            this.values[this.cursor] = value;
+            this.histograms[this.cursor] = null;
+        }
+        else {
+            const hv = value;
+            this.values[this.cursor] = hv.count;
+            this.histograms[this.cursor] = hv;
+        }
+        this.maxEndTime = endTime;
+        this.cursor++;
+        return true;
+    }
+    /**
+     * Binary search for first index with endTime >= targetTime
+     */
+    _binarySearchStart(targetTime) {
+        let left = 0;
+        let right = this.cursor - 1;
+        let result = this.cursor;
+        while (left <= right) {
+            const mid = (left + right) >> 1;
+            if (this.endTimes[mid] >= targetTime) {
+                result = mid;
+                right = mid - 1;
+            }
+            else {
+                left = mid + 1;
+            }
+        }
+        return result;
+    }
+    /**
+     * Binary search for last index with endTime <= targetTime
+     */
+    _binarySearchEnd(targetTime, startIdx = 0) {
+        let left = startIdx;
+        let right = this.cursor - 1;
+        let result = startIdx - 1;
+        while (left <= right) {
+            const mid = (left + right) >> 1;
+            if (this.endTimes[mid] <= targetTime) {
+                result = mid;
+                left = mid + 1;
+            }
+            else {
+                right = mid - 1;
+            }
+        }
+        return result;
+    }
+    /**
+     * Efficient slicing method for bulk operations.
+     * Always returns slices. Values can be either a Float64Array (numeric)
+     * or a JS array of HistogramValue objects (histogram series).
+     */
+    getSlices(startTime, endTime) {
+        const emptyResult = {
+            startTimes: new Float64Array(0),
+            endTimes: new Float64Array(0),
+            values: this.isHistogram ? [] : new Float64Array(0),
+        };
+        const start = startTime ?? 0;
+        const end = endTime ?? Number.MAX_SAFE_INTEGER;
+        if (this.cursor === 0 || this.maxEndTime < start || this.minEndTime > end) {
+            return emptyResult;
+        }
+        const startIdx = this._binarySearchStart(start);
+        const endIdx = this._binarySearchEnd(end, startIdx);
+        if (startIdx > endIdx) {
+            return emptyResult;
+        }
+        const startTimesNew = this.startTimes.subarray(startIdx, endIdx + 1);
+        const endTimesNew = this.endTimes.subarray(startIdx, endIdx + 1);
+        if (this.isHistogram) {
+            // Return histogram objects as a simple JS array slice
+            return {
+                startTimes: startTimesNew,
+                endTimes: endTimesNew,
+                values: this.histograms.slice(startIdx, endIdx + 1),
+            };
+        }
+        return {
+            startTimes: startTimesNew,
+            endTimes: endTimesNew,
+            values: this.values.subarray(startIdx, endIdx + 1),
+        };
+    }
+    isFull() {
+        return this.cursor >= this.maxSamples;
+    }
+    overlaps(startTime, endTime) {
+        if (this.cursor === 0)
+            return false;
+        return !(this.maxEndTime < startTime || this.minEndTime > endTime);
+    }
+    getStats() {
+        return {
+            samples: this.cursor,
+            maxSamples: this.maxSamples,
+            minEndTime: this.minEndTime,
+            maxEndTime: this.maxEndTime,
+            memoryBytes: this.getMemoryUsage(),
+        };
+    }
+    getMemoryUsage() {
+        const arrayMemory = this.maxSamples * 8 * 3;
+        const histogramMemory = this.histograms.filter(h => h !== null).length * 200;
+        return arrayMemory + histogramMemory;
+    }
+    getMinTime() {
+        return this.minEndTime;
+    }
+    getMaxTime() {
+        return this.maxEndTime;
+    }
+    size() {
+        return this.cursor;
+    }
+}

package/dist/esm/telemetry/custom-implementations/metrics/tsdb/Series.js

@@ -0,0 +1,164 @@
+/**
+ * Series: Time-series storage with metadata and chunks
+ * One series per unique metric+labels combination
+ */
+import { Chunk } from './Chunk.js';
+export class Series {
+    labelSet;
+    metadata;
+    chunks = [];
+    maxChunks;
+    chunkSize;
+    isHistogram;
+    constructor(labelSet, metadata, chunkSize = 120, maxChunks = 60 // ~1 hour at 1min intervals with 120 samples/chunk
+    ) {
+        this.labelSet = labelSet;
+        this.metadata = metadata;
+        this.chunkSize = chunkSize;
+        this.maxChunks = maxChunks;
+        this.isHistogram = metadata.dataPointType === 0; // HISTOGRAM = 0
+    }
+    /**
+     * Append a sample to the series
+     */
+    append(startTime, endTime, value) {
+        // Get or create current chunk
+        let currentChunk = this.chunks[this.chunks.length - 1];
+        if (!currentChunk || currentChunk.isFull()) {
+            // Create new chunk
+            currentChunk = new Chunk(this.chunkSize, this.isHistogram);
+            this.chunks.push(currentChunk);
+            // Enforce max chunks limit (circular buffer behavior)
+            if (this.chunks.length > this.maxChunks) {
+                this.chunks.shift(); // Remove oldest chunk
+            }
+        }
+        currentChunk.append(startTime, endTime, value);
+    }
+    /**
+     * Query slices with options object. Example:
+     *   querySlices({ startTime, endTime, includeStartTimes: true })
+     *   includeStartTimes defaults to false.
+     *   If both startTime and endTime are undefined, returns all data (no time filtering).
+     */
+    querySlices(options) {
+        const start = options?.startTime ?? 0;
+        const end = options?.endTime ?? Number.MAX_VALUE;
+        const includeStartTimes = options?.includeStartTimes ?? false;
+        let totalLength = 0;
+        for (const chunk of this.chunks) {
+            if (!chunk.overlaps(start, end))
+                continue;
+            const slice = chunk.getSlices(start, end);
+            totalLength += slice.startTimes.length;
+        }
+        if (totalLength === 0) {
+            const empty = {
+                endTimes: new Float64Array(0),
+                values: this.isHistogram ? [] : new Float64Array(0),
+            };
+            if (includeStartTimes) {
+                empty.startTimes = new Float64Array(0);
+            }
+            return empty;
+        }
+        let resultStart;
+        if (includeStartTimes) {
+            resultStart = new Float64Array(totalLength);
+        }
+        const resultEnd = new Float64Array(totalLength);
+        const resultValues = this.isHistogram
+            ? new Array(totalLength)
+            : new Float64Array(totalLength);
+        let offset = 0;
+        for (const chunk of this.chunks) {
+            if (!chunk.overlaps(start, end))
+                continue;
+            const slice = chunk.getSlices(start, end);
+            const len = slice.startTimes.length;
+            if (len === 0)
+                continue;
+            // Copy start and end times
+            if (includeStartTimes && resultStart) {
+                resultStart.set(slice.startTimes, offset);
+            }
+            resultEnd.set(slice.endTimes, offset);
+            // Copy values (different type depending on metric)
+            if (this.isHistogram) {
+                resultValues.splice(offset, len, ...slice.values);
+            }
+            else {
+                resultValues.set(slice.values, offset);
+            }
+            offset += len;
+        }
+        const result = {
+            endTimes: resultEnd,
+            values: resultValues
+        };
+        if (includeStartTimes && resultStart) {
+            result.startTimes = resultStart;
+        }
+        return result;
+    }
+    /**
+     * Remove chunks older than threshold
+     */
+    evictOldChunks(thresholdTime) {
+        let evicted = 0;
+        while (this.chunks.length > 0 && this.chunks[0].getMaxTime() < thresholdTime) {
+            this.chunks.shift();
+            evicted++;
+        }
+        return evicted;
+    }
+    /**
+     * Get series metadata
+     */
+    getMetadata() {
+        return this.metadata;
+    }
+    getLabels() {
+        return this.labelSet.labels;
+    }
+    getOriginalAttributes() {
+        return this.labelSet.originalAttributes;
+    }
+    /**
+     * Get label hash
+     */
+    getLabelHash() {
+        return this.labelSet.hash;
+    }
+    getStats() {
+        const totalSamples = this.chunks.reduce((sum, chunk) => sum + chunk.size(), 0);
+        const memoryBytes = this.chunks.reduce((sum, chunk) => sum + chunk.getMemoryUsage(), 0);
+        return {
+            metricName: this.metadata?.descriptor?.name ?? 'unknown',
+            labels: this.labelSet?.labels ?? {},
+            chunks: this.chunks.length,
+            samples: totalSamples,
+            memoryBytes,
+            oldestTime: this.chunks[0]?.getMinTime() ?? 0,
+            newestTime: this.chunks[this.chunks.length - 1]?.getMaxTime() ?? 0
+        };
+    }
+    /**
+     * Check if series has any samples
+     */
+    isEmpty() {
+        return this.chunks.length === 0 || this.chunks.every(c => c.size() === 0);
+    }
+    /**
+     * Get time range covered by this series
+     */
+    getTimeRange() {
+        if (this.chunks.length === 0) {
+            return { min: 0, max: 0 };
+        }
+        return {
+            min: this.chunks[0].getMinTime(),
+            max: this.chunks[this.chunks.length - 1].getMaxTime()
+        };
+    }
+}