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

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

@@ -1,199 +1,203 @@
 "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.InMemoryDbLogExporter = void 0;
-var _core = require("@opentelemetry/core");
-var _nedb = _interopRequireDefault(require("@seald-io/nedb"));
-var _minisearch = _interopRequireDefault(require("minisearch"));
-var _circular = require("../utils/circular.cjs");
-var _wrappers = require("../wrappers.cjs");
-var _logger = _interopRequireDefault(require("../../../utils/logger.cjs"));
-var _pluginService = require("../../../tlm-plugin/pluginService.cjs");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
-function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
-function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
-function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
-function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
-class InMemoryDbLogExporter extends _wrappers.Enabler {
-  constructor(retentionTimeInSeconds = 3600) {
-    super();
-    this._retentionTimeInSeconds = retentionTimeInSeconds;
-    this._db = new _nedb.default({
-      timestampData: true
-    });
-    this._db.ensureIndex({
-      fieldName: 'createdAt'
-    });
-    this._miniSearch = new _minisearch.default({
-      fields: ['body'],
-      storeFields: ['_id'],
-      idField: '_id'
-    });
-    this._startCleanupJob();
-  }
-  /*
-  * SUPER WARNING:
-  * Do NOT use console.log, console.error, or any logger inside this class's export function.
-  * Doing so will cause an infinite loop.
-  * Only console.dir is allowed, as it is not tracked by our log export implementation.
-  */
-  /**
-   * Export logs.
-   * @param logs
-   * @param resultCallback
-   */
-  export(logs, resultCallback) {
-    const logsToInsert = logs.map(logRecord => {
-      // Remove circular references first, then apply nesting, then export info
-      const formattedLog = this._formatLogRecord(logRecord);
-      const cleanedLog = (0, _circular.removeCircularRefs)(formattedLog);
-      const nestedLog = (0, _circular.applyNesting)(cleanedLog);
-      return nestedLog;
-    });
-    logsToInsert.forEach(log => {
-      _pluginService.pluginService.broadcastLog(log);
-    });
-    // ENABLED only affect storage not plugin broadcasting
-    if (this.isEnabled()) {
-      this._insertLogs(logsToInsert, resultCallback);
+const core_1 = require("@opentelemetry/core");
+const core_2 = require("@opentelemetry/core");
+const nedb_1 = __importDefault(require("@seald-io/nedb"));
+const minisearch_1 = __importDefault(require("minisearch"));
+const circular_js_1 = require("../utils/circular.cjs");
+const wrappers_js_1 = require("../wrappers.cjs");
+const logger_js_1 = __importDefault(require("../../../utils/logger.cjs"));
+const pluginService_js_1 = require("../../../tlm-plugin/pluginService.cjs");
+class InMemoryDbLogExporter extends wrappers_js_1.Enabler {
+    _db = null;
+    _miniSearch = null;
+    _retentionTimeInSeconds;
+    _initialized = false;
+    constructor(retentionTimeInSeconds = 3600) {
+        super();
+        this._retentionTimeInSeconds = retentionTimeInSeconds;
+        this._startCleanupJob();
     }
-    resultCallback({
-      code: _core.ExportResultCode.SUCCESS
-    });
-  }
-  reset() {
-    this._db = new _nedb.default();
-    this._miniSearch = new _minisearch.default({
-      fields: ['body'],
-      storeFields: ['_id'],
-      idField: '_id'
-    });
-  }
-  /**
-   * Shutdown the exporter.
-   */
-  async shutdown() {
-    this._db = null;
-    this._miniSearch = null;
-  }
-  async find(findConfig) {
-    const {
-      query,
-      messageSearch,
-      limit,
-      sortOrder
-    } = findConfig;
-    const finalQuery = _objectSpread({}, query);
-    const effectiveSortOrder = sortOrder || {
-      timestamp: -1
-    };
-    if (messageSearch) {
-      const searchResults = this._miniSearch.search(messageSearch, {
-        prefix: true,
-        fuzzy: 0.2
-      });
-      const ids = searchResults.map(result => result._id);
-      _logger.default.debug(`MiniSearch found ${ids.length} results for search term "${messageSearch}"`, {
-        depth: 3
-      });
-      finalQuery._id = {
-        $in: ids
-      };
-    }
-    const docs = await new Promise((resolve, reject) => {
-      this._db.find(finalQuery).sort(effectiveSortOrder).limit(limit).exec((err, docs) => {
-        if (err) reject(err);else resolve(docs);
-      });
-    });
-    return docs;
-  }
-  insert(data, callback) {
-    this._insertLogs(data, result => {
-      if (result.code === _core.ExportResultCode.SUCCESS) {
-        this._db.find({}, (err, docs) => {
-          if (err) {
-            _logger.default.debug(err);
-            callback(err, []);
+    _ensureInitialized() {
+        if (this._initialized)
             return;
-          }
-          callback(null, docs);
+        this._initialized = true;
+        this._db = new nedb_1.default({ timestampData: true });
+        this._db.ensureIndex({ fieldName: 'createdAt' });
+        this._miniSearch = new minisearch_1.default({
+            fields: ['body'],
+            storeFields: ['_id'],
+            idField: '_id',
         });
-      } else {
-        callback(new Error('Failed to insert logs'), []);
-      }
-    });
-  }
-  getFinishedLogs() {
-    return this._db.getAllData();
-  }
-  /**
-   *  @copyright The OpenTelemetry Authors
-   *  @license Apache-2.0
-   * converts logRecord info into more readable format
-   * @param logRecord
-   */
-  _formatLogRecord(logRecord) {
-    return {
-      resource: {
-        attributes: logRecord.resource.attributes
-      },
-      instrumentationScope: logRecord.instrumentationScope,
-      timestamp: (0, _core.hrTimeToMicroseconds)(logRecord.hrTime) ?? Date.now(),
-      observedTimestamp: (0, _core.hrTimeToMicroseconds)(logRecord.hrTimeObserved) ?? Date.now(),
-      traceId: logRecord.spanContext?.traceId,
-      spanId: logRecord.spanContext?.spanId,
-      traceFlags: logRecord.spanContext?.traceFlags,
-      severityText: logRecord.severityText,
-      severityNumber: logRecord.severityNumber,
-      body: logRecord.body,
-      attributes: logRecord.attributes
-    };
-  }
-  set retentionTimeInSeconds(retentionTimeInSeconds) {
-    this._retentionTimeInSeconds = retentionTimeInSeconds;
-    _logger.default.info(`InMemoryDbLogExporter retention time set to ${this._retentionTimeInSeconds} seconds`);
-  }
-  get retentionTimeInSeconds() {
-    return this._retentionTimeInSeconds;
-  }
-  _insertLogs(logsToInsert, resultCallback) {
-    this._db.insert(logsToInsert, (err, newDocs) => {
-      if (err) {
-        console.dir(err);
-        resultCallback({
-          code: _core.ExportResultCode.FAILED
+        logger_js_1.default.info(`[LogExporter] In-memory storage created`);
+    }
+    /*
+    * SUPER WARNING:
+    * Do NOT use console.log, console.error, or any logger inside this class's export function.
+    * Doing so will cause an infinite loop.
+    * Only console.dir is allowed, as it is not tracked by our log export implementation.
+    */
+    /**
+     * Export logs.
+     * @param logs
+     * @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);
+            const cleanedLog = (0, circular_js_1.removeCircularRefs)(formattedLog);
+            const nestedLog = (0, circular_js_1.applyNesting)(cleanedLog);
+            return nestedLog;
         });
-        return;
-      }
-      // console.dir(newDocs, { depth: 3 });
-      newDocs.forEach(doc => this._miniSearch.add(doc));
-      resultCallback({
-        code: _core.ExportResultCode.SUCCESS
-      });
-    });
-    return;
-  }
-  _startCleanupJob() {
-    const interval = 1000;
-    setInterval(() => {
-      const expirationDate = new Date(Date.now() - this._retentionTimeInSeconds * 1000);
-      this._db.remove({
-        createdAt: {
-          $lt: expirationDate
+        logsToInsert.forEach(log => {
+            pluginService_js_1.pluginService.broadcastLog(log);
+        });
+        // ENABLED only affect storage not plugin broadcasting
+        if (this.isEnabled()) {
+            this._insertLogs(logsToInsert, resultCallback);
         }
-      }, {
-        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 logs`);
+        resultCallback({ code: core_2.ExportResultCode.SUCCESS });
+    }
+    reset() {
+        this._ensureInitialized();
+        // Remove all logs from the in-memory database.
+        this._db.remove({}, { multi: true }, (err) => {
+            if (err) {
+                logger_js_1.default.error(`[LogExporter] Error during reset: ${err.message}`);
+            }
+            else {
+                logger_js_1.default.info(`[LogExporter] Reset - all logs cleared`);
+            }
+        });
+        // Clear mini search index
+        this._miniSearch = new minisearch_1.default({
+            fields: ['body'],
+            storeFields: ['_id'],
+            idField: '_id',
+        });
+    }
+    /**
+     * Shutdown the exporter.
+     */
+    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 };
+        if (messageSearch) {
+            const searchResults = this._miniSearch.search(messageSearch, { prefix: true, fuzzy: 0.2 });
+            const ids = searchResults.map((result) => result._id);
+            logger_js_1.default.debug(`MiniSearch found ${ids.length} results for search term "${messageSearch}"`, { depth: 3 });
+            finalQuery._id = { $in: ids };
         }
-      });
-    }, interval);
-  }
+        const docs = await new Promise((resolve, reject) => {
+            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
+                    resolve(docs);
+            });
+        });
+        return docs;
+    }
+    insert(data, callback) {
+        this._insertLogs(data, (result) => {
+            if (result.code === core_2.ExportResultCode.SUCCESS) {
+                this._db.find({}, (err, docs) => {
+                    if (err) {
+                        logger_js_1.default.debug(err);
+                        callback(err, []);
+                        return;
+                    }
+                    callback(null, docs);
+                });
+            }
+            else {
+                callback(new Error('Failed to insert logs'), []);
+            }
+        });
+    }
+    getFinishedLogs() {
+        this._ensureInitialized();
+        return this._db.getAllData();
+    }
+    /**
+     *  @copyright The OpenTelemetry Authors
+     *  @license Apache-2.0
+     * converts logRecord info into more readable format
+     * @param logRecord
+     */
+    _formatLogRecord(logRecord) {
+        return {
+            resource: {
+                attributes: logRecord.resource.attributes,
+            },
+            instrumentationScope: logRecord.instrumentationScope,
+            timestamp: (0, core_1.hrTimeToMicroseconds)(logRecord.hrTime) ?? Date.now(),
+            observedTimestamp: (0, core_1.hrTimeToMicroseconds)(logRecord.hrTimeObserved) ?? Date.now(),
+            traceId: logRecord.spanContext?.traceId,
+            spanId: logRecord.spanContext?.spanId,
+            traceFlags: logRecord.spanContext?.traceFlags,
+            severityText: logRecord.severityText,
+            severityNumber: logRecord.severityNumber,
+            body: logRecord.body,
+            attributes: logRecord.attributes,
+        };
+    }
+    set retentionTimeInSeconds(retentionTimeInSeconds) {
+        this._retentionTimeInSeconds = retentionTimeInSeconds;
+        logger_js_1.default.info(`InMemoryDbLogExporter retention time set to ${this._retentionTimeInSeconds} seconds`);
+    }
+    get retentionTimeInSeconds() {
+        return this._retentionTimeInSeconds;
+    }
+    _insertLogs(logsToInsert, resultCallback) {
+        if (!this._db)
+            return resultCallback({ code: core_2.ExportResultCode.FAILED });
+        this._db.insert(logsToInsert, (err, newDocs) => {
+            if (err) {
+                console.dir(err);
+                resultCallback({ code: core_2.ExportResultCode.FAILED });
+                return;
+            }
+            // console.dir(newDocs, { depth: 3 });
+            newDocs.forEach((doc) => this._miniSearch?.add(doc));
+            resultCallback({ code: core_2.ExportResultCode.SUCCESS });
+        });
+        return;
+    }
+    _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) {
+                    logger_js_1.default.error('Error in TTL cleanup:', err);
+                }
+                else if (numRemoved > 0) {
+                    logger_js_1.default.debug(`TTL cleanup: removed ${numRemoved} expired logs`);
+                }
+            });
+        }, interval);
+    }
 }
-exports.InMemoryDbLogExporter = InMemoryDbLogExporter;
+exports.InMemoryDbLogExporter = InMemoryDbLogExporter;

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

@@ -1,105 +1,153 @@
 "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.InMemoryDbMetricExporter = void 0;
-var _core = require("@opentelemetry/core");
-var _nedb = _interopRequireDefault(require("@seald-io/nedb"));
-var _circular = require("../utils/circular.cjs");
-var _wrappers = require("../wrappers.cjs");
-var _logger = _interopRequireDefault(require("../../../utils/logger.cjs"));
-var _pluginService = require("../../../tlm-plugin/pluginService.cjs");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-class InMemoryDbMetricExporter extends _wrappers.Enabler {
-  constructor(retentionTimeInSeconds = 3600) {
-    super();
-    this._retentionTimeInSeconds = retentionTimeInSeconds;
-    this._metrics = new _nedb.default({
-      timestampData: true
-    });
-    this._metrics.ensureIndex({
-      fieldName: 'createdAt'
-    });
-    this._startCleanupJob();
-  }
-  export(metrics, resultCallback) {
-    try {
-      const scopeMetrics = metrics?.scopeMetrics;
-      const cleanMetrics = (0, _circular.applyNesting)(scopeMetrics);
-      cleanMetrics.forEach(metric => {
-        _pluginService.pluginService.broadcastMetric(metric);
-      });
-      // Insert only if exporter is enabled
-      if (this.isEnabled()) {
-        this._metrics.insert(cleanMetrics, (err, _newDoc) => {
-          if (err) {
-            _logger.default.error('Insertion Error:', err);
+const core_1 = require("@opentelemetry/core");
+const wrappers_js_1 = require("../wrappers.cjs");
+const logger_js_1 = __importDefault(require("../../../utils/logger.cjs"));
+const pluginService_js_1 = require("../../../tlm-plugin/pluginService.cjs");
+const utils_js_1 = require("../metrics/tsdb/utils.cjs");
+const SeriesRegistry_js_1 = require("../metrics/tsdb/SeriesRegistry.cjs");
+/**
+ * In-Memory TSDB Metric Exporter
+ * Series identified by: scope + metricName + attributes
+ */
+class InMemoryDbMetricExporter extends wrappers_js_1.Enabler {
+    static DEFAULT_CONFIG = {
+        retentionTimeInSeconds: 3600,
+        chunkSize: 120,
+        maxChunks: 60
+    };
+    registry;
+    config;
+    cachedResource = null;
+    _initialized = false;
+    _ensureInitialized() {
+        if (this._initialized)
             return;
-          }
-        });
-      }
-      setTimeout(() => resultCallback({
-        code: _core.ExportResultCode.SUCCESS
-      }), 0);
-    } catch (error) {
-      _logger.default.error('Error exporting metrics\n' + error.message + '\n' + error.stack);
-      return resultCallback({
-        code: _core.ExportResultCode.FAILED,
-        error: new Error('Error exporting metrics\n' + error.message + '\n' + error.stack)
-      });
-    }
-  }
-  shutdown() {
-    this._enabled = false;
-    this._metrics = new _nedb.default();
-    return this.forceFlush();
-  }
-  forceFlush() {
-    return Promise.resolve();
-  }
-  find(search, callback) {
-    this._metrics.find(search, callback);
-  }
-  reset() {
-    this._metrics = new _nedb.default();
-  }
-  getFinishedMetrics() {
-    return this._metrics.getAllData();
-  }
-  /**
-   * Inserts metrics into the in-memory database.
-   * @param metrics - The metrics to insert.
-   * @param callback - The callback to execute after insertion.
-   */
-  insert(metrics, callback) {
-    this._metrics.insert(metrics, callback);
-  }
-  set retentionTimeInSeconds(retentionTimeInSeconds) {
-    this._retentionTimeInSeconds = retentionTimeInSeconds;
-    _logger.default.info(`InMemoryDbMetricExporter retention time set to ${this._retentionTimeInSeconds} seconds`);
-  }
-  get retentionTimeInSeconds() {
-    return this._retentionTimeInSeconds;
-  }
-  _startCleanupJob() {
-    const interval = 1000;
-    setInterval(() => {
-      const expirationDate = new Date(Date.now() - this._retentionTimeInSeconds * 1000);
-      this._metrics.remove({
-        createdAt: {
-          $lt: expirationDate
+        this._initialized = true;
+        logger_js_1.default.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.config = { ...InMemoryDbMetricExporter.DEFAULT_CONFIG, ...config };
+        this.registry = new SeriesRegistry_js_1.SeriesRegistry(this.config.chunkSize, this.config.maxChunks);
+        this._startCleanupJob();
+    }
+    export(resourceMetrics, resultCallback) {
+        this._ensureInitialized();
+        try {
+            // Cache resource (unique per exporter instance)
+            if (!this.cachedResource) {
+                this.cachedResource = resourceMetrics.resource;
+            }
+            const scopeMetrics = resourceMetrics.scopeMetrics;
+            // Broadcast to plugins
+            scopeMetrics?.forEach((metric) => {
+                pluginService_js_1.pluginService.broadcastMetric(metric);
+            });
+            // Store if enabled - use new storeScopeMetrics method
+            if (this.isEnabled() && scopeMetrics) {
+                this.registry.storeScopeMetrics(scopeMetrics);
+            }
+            setTimeout(() => resultCallback({ code: core_1.ExportResultCode.SUCCESS }), 0);
         }
-      }, {
-        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 metrics`);
+        catch (error) {
+            logger_js_1.default.error('Error exporting metrics\n' + error.message + '\n' + error.stack);
+            return resultCallback({
+                code: core_1.ExportResultCode.FAILED,
+                error: new Error('Error exporting metrics\n' + error.message + '\n' + error.stack),
+            });
         }
-      });
-    }, interval);
-  }
+    }
+    shutdown() {
+        this._enabled = false;
+        this.registry.reset();
+        return this.forceFlush();
+    }
+    reset() {
+        this._ensureInitialized();
+        this.registry.reset();
+        logger_js_1.default.info(`[MetricExporter] Reset - all metrics cleared`);
+    }
+    forceFlush() {
+        return Promise.resolve();
+    }
+    getCachedResource() {
+        return this.cachedResource;
+    }
+    set retentionTimeInSeconds(value) {
+        this.config.retentionTimeInSeconds = value;
+        logger_js_1.default.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_js_1.default.debug(`Cleanup: evicted ${result.evictedChunks} chunks, ${result.evictedSeries} series`);
+            }
+        }, 5000);
+    }
+    /**
+     * 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: (0, utils_js_1.rawToOtel)(rawResults) };
+        }
+        return { results: rawResults };
+    }
+    /**
+     * Export all metrics as line-delimited JSON (one chunk per line)
+     */
+    exportToLineDelimitedJson() {
+        return this.registry.serializeToLineDelimitedJson();
+    }
+    /**
+     * Import metrics from line-delimited JSON format
+     */
+    importFromLineDelimitedJson(lineDelimitedJsonData) {
+        this.registry.deserializeFromLineDelimitedJson(lineDelimitedJsonData);
+    }
+    /**
+ * 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);
+        }
+    }
+    /**
+     * Insert metrics in raw format (MetricQueryResult[]), converts to OTEL and delegates to insertOtel
+     * @param rawScopeMetrics Array of MetricQueryResult (raw format)
+     */
+    insertRaw(rawScopeMetrics) {
+        const otelScopeMetrics = (0, utils_js_1.rawToOtel)(rawScopeMetrics);
+        this.insertOtel(otelScopeMetrics);
+    }
 }
-exports.InMemoryDbMetricExporter = InMemoryDbMetricExporter;
+exports.InMemoryDbMetricExporter = InMemoryDbMetricExporter;