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

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

@@ -1,123 +1,150 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.InMemoryDbSpanExporter = void 0;
-var _core = require("@opentelemetry/core");
-var _nedb = _interopRequireDefault(require("@seald-io/nedb"));
-var _logger = _interopRequireDefault(require("../../../utils/logger.cjs"));
-var _circular = require("../utils/circular.cjs");
-var _wrappers = require("../wrappers.cjs");
-var _pluginService = require("../../../tlm-plugin/pluginService.cjs");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-class InMemoryDbSpanExporter extends _wrappers.Enabler {
-  constructor(retentionTimeInSeconds = 3600) {
-    super();
-    this._baseUrl = '/telemetry'; // Default base URL, can be overridden by the config
-    this._retentionTimeInSeconds = retentionTimeInSeconds;
-    this._spans = new _nedb.default({
-      timestampData: true
-    });
-    this._spans.ensureIndex({
-      fieldName: 'createdAt'
-    });
-    this._startCleanupJob();
-  }
-  set baseUrl(baseUrl) {
-    this._baseUrl = baseUrl;
-  }
-  set retentionTimeInSeconds(retentionTimeInSeconds) {
-    this._retentionTimeInSeconds = retentionTimeInSeconds;
-    _logger.default.info(`InMemoryDbSpanExporter retention time set to ${this._retentionTimeInSeconds} seconds`);
-  }
-  get retentionTimeInSeconds() {
-    return this._retentionTimeInSeconds;
-  }
-  export(readableSpans, resultCallback) {
-    _logger.default.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 => (0, _circular.removeCircularRefs)(nestedSpan)) // to avoid JSON parsing error
-      .map(span => (0, _circular.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;
-      });
-      cleanSpans.forEach(span => {
-        _pluginService.pluginService.broadcastTrace(span);
-      });
-      // 
-      if (this.isEnabled()) {
-        // Insert spans into the in-memory database
-        this._spans.insert(cleanSpans, (err, _newDoc) => {
-          if (err) {
-            _logger.default.error(err);
+const core_1 = require("@opentelemetry/core");
+const nedb_1 = __importDefault(require("@seald-io/nedb"));
+const logger_js_1 = __importDefault(require("../../../utils/logger.cjs"));
+const circular_js_1 = require("../utils/circular.cjs");
+const wrappers_js_1 = require("../wrappers.cjs");
+const pluginService_js_1 = require("../../../tlm-plugin/pluginService.cjs");
+class InMemoryDbSpanExporter extends wrappers_js_1.Enabler {
+    _spans = null;
+    _retentionTimeInSeconds;
+    _initialized = false;
+    constructor(retentionTimeInSeconds = 3600) {
+        super();
+        this._retentionTimeInSeconds = retentionTimeInSeconds;
+        this._startCleanupJob();
+    }
+    ;
+    _ensureInitialized() {
+        if (this._initialized)
             return;
-          }
-        });
-      }
-      return resultCallback({
-        code: _core.ExportResultCode.SUCCESS
-      });
-    } catch (error) {
-      _logger.default.error('Error exporting spans\n' + error.message + '\n' + error.stack);
-      return resultCallback({
-        code: _core.ExportResultCode.FAILED,
-        error: new Error('Error exporting spans\n' + error.message + '\n' + error.stack)
-      });
+        this._initialized = true;
+        this._spans = new nedb_1.default({ timestampData: true });
+        this._spans.ensureIndex({ fieldName: 'createdAt' });
+        logger_js_1.default.info(`[SpanExporter] In-memory storage created`);
+    }
+    set retentionTimeInSeconds(retentionTimeInSeconds) {
+        this._retentionTimeInSeconds = retentionTimeInSeconds;
+        logger_js_1.default.info(`InMemoryDbSpanExporter retention time set to ${this._retentionTimeInSeconds} seconds`);
     }
-  }
-  shutdown() {
-    this._spans = new _nedb.default();
-    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 _nedb.default();
-  }
-  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
+    get retentionTimeInSeconds() {
+        return this._retentionTimeInSeconds;
+    }
+    export(readableSpans, resultCallback) {
+        this._ensureInitialized();
+        logger_js_1.default.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 => (0, circular_js_1.removeCircularRefs)(nestedSpan)) // to avoid JSON parsing error
+                .map(span => (0, circular_js_1.applyNesting)(span)); // to avoid dot notation in keys (neDB does not support dot notation in keys)
+            cleanSpans.forEach(span => {
+                pluginService_js_1.pluginService.broadcastTrace(span);
+            });
+            if (this.isEnabled()) {
+                // Insert spans into the in-memory database
+                if (this._spans) {
+                    this._spans.insert(cleanSpans, (err, _newDoc) => {
+                        if (err) {
+                            logger_js_1.default.error(err);
+                            return;
+                        }
+                    });
+                }
+            }
+            return resultCallback({ code: core_1.ExportResultCode.SUCCESS });
+        }
+        catch (error) {
+            logger_js_1.default.error('Error exporting spans\n' + error.message + '\n' + error.stack);
+            return resultCallback({
+                code: core_1.ExportResultCode.FAILED,
+                error: new Error('Error exporting spans\n' + error.message + '\n' + error.stack),
+            });
         }
-      }, {
-        multi: true
-      }, (err, numRemoved) => {
-        if (err) {
-          _logger.default.error('Error in TTL cleanup:', err);
-        } else if (numRemoved > 0) {
-          _logger.default.debug(`TTL cleanup: removed ${numRemoved} expired spans`);
+    }
+    ;
+    shutdown() {
+        this._spans = null;
+        return this.forceFlush();
+    }
+    ;
+    reset() {
+        this._ensureInitialized();
+        this._spans.remove({}, { multi: true }, (err) => {
+            if (err) {
+                logger_js_1.default.error(`[SpanExporter] Error during reset: ${err.message}`);
+            }
+            else {
+                logger_js_1.default.info(`[SpanExporter] Reset - all spans cleared`);
+            }
+        });
+    }
+    /**
+     * Exports any pending spans in the exporter
+     */
+    forceFlush() {
+        return Promise.resolve();
+    }
+    ;
+    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();
+    }
+    ;
+    /**
+     * 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._ensureInitialized();
+        if (!this._spans) {
+            return callback(new Error('Spans database not initialized'), []);
         }
-      });
-    }, interval);
-  }
+        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) {
+                    logger_js_1.default.error('Error in TTL cleanup:', err);
+                }
+                else if (numRemoved > 0) {
+                    logger_js_1.default.debug(`TTL cleanup: removed ${numRemoved} expired spans`);
+                }
+            });
+        }, interval);
+    }
 }
-exports.InMemoryDbSpanExporter = InMemoryDbSpanExporter;
+exports.InMemoryDbSpanExporter = InMemoryDbSpanExporter;

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

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MultiMetricExporter = void 0;
+const core_1 = require("@opentelemetry/core");
+class MultiMetricExporter {
+    exporters;
+    constructor(exporters) {
+        this.exporters = exporters;
+    }
+    export(resourceMetrics, resultCallback) {
+        if (!this.exporters.length) {
+            resultCallback({ code: core_1.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 === core_1.ExportResultCode.FAILED) {
+                        failed = true;
+                        if (result.error && !firstError) {
+                            firstError = result.error;
+                        }
+                    }
+                    pending -= 1;
+                    if (pending === 0) {
+                        resultCallback(failed
+                            ? { code: core_1.ExportResultCode.FAILED, error: firstError }
+                            : { code: core_1.ExportResultCode.SUCCESS });
+                    }
+                });
+            }
+            catch (error) {
+                failed = true;
+                if (!firstError) {
+                    firstError = error instanceof Error ? error : new Error(String(error));
+                }
+                pending -= 1;
+                if (pending === 0) {
+                    resultCallback({ code: core_1.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()));
+    }
+}
+exports.MultiMetricExporter = MultiMetricExporter;

package/dist/cjs/telemetry/custom-implementations/instrumentations/logsInstrumentation.cjs

@@ -0,0 +1,92 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogsInstrumentation = void 0;
+const instrumentation_1 = require("@opentelemetry/instrumentation");
+const api_logs_1 = require("@opentelemetry/api-logs");
+const util_1 = __importDefault(require("util"));
+const telemetryRegistry_js_1 = require("../../telemetryRegistry.cjs");
+class LogsInstrumentation extends instrumentation_1.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(telemetryRegistry_js_1.originalConsoleMethods).forEach((method) => {
+            const original = telemetryRegistry_js_1.originalConsoleMethods[method];
+            console[method] = (...args) => {
+                const { number, text } = getSeverityForMethod(method);
+                this._otelLogger.emit({
+                    severityNumber: number,
+                    severityText: text,
+                    body: util_1.default.format(...args),
+                    attributes: {
+                        source: `console.${method}`,
+                        library: this.instrumentationName,
+                    },
+                });
+                original(...args);
+            };
+        });
+    }
+    _unpatchConsole() {
+        Object.keys(telemetryRegistry_js_1.originalConsoleMethods).forEach((method) => {
+            console[method] = telemetryRegistry_js_1.originalConsoleMethods[method];
+        });
+    }
+}
+exports.LogsInstrumentation = LogsInstrumentation;
+function getSeverityForMethod(method) {
+    switch (method) {
+        case "log":
+        case "info":
+            return { number: api_logs_1.SeverityNumber.INFO, text: "INFO" };
+        case "debug":
+            return { number: api_logs_1.SeverityNumber.DEBUG, text: "DEBUG" };
+        case "warn":
+            return { number: api_logs_1.SeverityNumber.WARN, text: "WARN" };
+        case "error":
+            return { number: api_logs_1.SeverityNumber.ERROR, text: "ERROR" };
+        default:
+            return { number: api_logs_1.SeverityNumber.INFO, text: "INFO" };
+    }
+}

package/dist/cjs/telemetry/custom-implementations/metrics/tsdb/Chunk.cjs

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Chunk = void 0;
+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;
+    }
+}
+exports.Chunk = Chunk;