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

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

@@ -1,105 +1,210 @@
 "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");
+const storagePath_js_1 = require("../utils/storagePath.cjs");
+const fs_1 = __importDefault(require("fs"));
+/**
+ * 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;
+    _storageFilePath = null;
+    _autoSaveInterval = null;
+    _storageLogged = false; // Track if we've logged storage info
+    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);
+        // Load persisted metrics if disk storage is enabled
+        this._storageFilePath = (0, storagePath_js_1.getStoragePath)('metrics');
+        if (this._storageFilePath) {
+            this._loadMetricsFromDisk();
+            this._startAutoSave();
+        }
+        this._startCleanupJob();
+    }
+    _loadMetricsFromDisk() {
+        if (!this._storageFilePath)
+            return;
+        try {
+            if (fs_1.default.existsSync(this._storageFilePath)) {
+                const ndjsonData = fs_1.default.readFileSync(this._storageFilePath, 'utf-8');
+                this.registry.deserializeFromNDJSON(ndjsonData);
+            }
+        }
+        catch {
+            // Silently fail during boot
+        }
+    }
+    _startAutoSave() {
+        if (!this._storageFilePath)
+            return;
+        // Save every 30 seconds
+        this._autoSaveInterval = setInterval(() => {
+            this._saveMetricsToDisk();
+        }, 30000);
+    }
+    _saveMetricsToDisk() {
+        if (!this._storageFilePath)
             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
+        try {
+            const ndjsonData = this.registry.serializeToNDJSON();
+            fs_1.default.writeFileSync(this._storageFilePath, ndjsonData);
         }
-      }, {
-        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 {
+            // Silently fail to avoid logging issues
         }
-      });
-    }, interval);
-  }
+    }
+    export(resourceMetrics, resultCallback) {
+        // Log storage info on first export (when logger is ready)
+        if (!this._storageLogged) {
+            this._storageLogged = true;
+            if (this._storageFilePath) {
+                logger_js_1.default.info(`[MetricExporter] Disk storage enabled at: ${this._storageFilePath} (auto-save every 30s)`);
+            }
+            else {
+                logger_js_1.default.info(`[MetricExporter] Using in-memory storage`);
+            }
+        }
+        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);
+        }
+        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),
+            });
+        }
+    }
+    shutdown() {
+        this._enabled = false;
+        // Stop auto-save and save one final time
+        if (this._autoSaveInterval) {
+            clearInterval(this._autoSaveInterval);
+            this._autoSaveInterval = null;
+        }
+        if (this._storageFilePath) {
+            this._saveMetricsToDisk();
+            logger_js_1.default.info(`[MetricExporter] Metrics saved to disk at shutdown`);
+        }
+        this.registry.reset();
+        return this.forceFlush();
+    }
+    reset() {
+        // Clear metrics but save empty state to disk
+        this.registry.reset();
+        if (this._storageFilePath) {
+            this._saveMetricsToDisk();
+            logger_js_1.default.info(`[MetricExporter] Reset - all metrics cleared and saved to disk`);
+        }
+        else {
+            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() {
+        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) {
+        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 to NDJSON format (one chunk per line)
+     */
+    exportToNDJSON() {
+        return this.registry.serializeToNDJSON();
+    }
+    /**
+     * Import metrics from NDJSON format
+     */
+    importFromNDJSON(ndjsonData) {
+        this.registry.deserializeFromNDJSON(ndjsonData);
+    }
+    /**
+ * Insert metrics in OpenTelemetry (OTEL) format directly into the registry
+ * @param scopeMetrics Array of ScopeMetrics (OTEL format)
+ */
+    insertOtel(scopeMetrics) {
+        // 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;

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

@@ -1,123 +1,159 @@
 "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");
+const storagePath_js_1 = require("../utils/storagePath.cjs");
+class InMemoryDbSpanExporter extends wrappers_js_1.Enabler {
+    _spans = null;
+    _retentionTimeInSeconds;
+    _storagePath = null;
+    _initialized = false;
+    constructor(retentionTimeInSeconds = 3600) {
+        super();
+        this._retentionTimeInSeconds = retentionTimeInSeconds;
+        this._storagePath = (0, storagePath_js_1.getStoragePath)('traces');
+        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(this._storagePath ? { filename: this._storagePath, timestampData: true, autoload: true } : { timestampData: true });
+        this._spans.ensureIndex({ fieldName: 'createdAt' });
+        if (this._storagePath) {
+            logger_js_1.default.info(`[SpanExporter] Disk storage enabled at: ${this._storagePath}`);
+        }
+        else {
+            logger_js_1.default.info(`[SpanExporter] Using in-memory storage`);
+        }
     }
-  }
-  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
+    set retentionTimeInSeconds(retentionTimeInSeconds) {
+        this._retentionTimeInSeconds = retentionTimeInSeconds;
+        logger_js_1.default.info(`InMemoryDbSpanExporter retention time set to ${this._retentionTimeInSeconds} seconds`);
+    }
+    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 });
         }
-      }, {
-        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`);
+        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),
+            });
+        }
+    }
+    ;
+    shutdown() {
+        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_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/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" };
+    }
+}