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

package/dist/cjs/telemetry/custom-implementations/wrappers.cjs

@@ -1,35 +1,36 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.EnablerSpanExporter = exports.EnablerMultiSpanExporter = exports.EnablerMultiLogExporter = exports.EnablerMetricReader = exports.EnablerLogExporter = exports.Enabler = void 0;
-var _resources = require("@opentelemetry/resources");
-var _logger = _interopRequireDefault(require("../../utils/logger.cjs"));
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnablerMetricReader = exports.EnablerMultiLogExporter = exports.EnablerMultiSpanExporter = exports.EnablerLogExporter = exports.EnablerSpanExporter = exports.Enabler = void 0;
+const core_1 = require("@opentelemetry/core");
+const resources_1 = require("@opentelemetry/resources");
+const logger_js_1 = __importDefault(require("../../utils/logger.cjs"));
 class Enabler {
-  constructor(enabled) {
-    this._enabled = true;
-    if (typeof enabled === 'boolean') {
-      this._enabled = enabled;
-    }
-  }
-  setEnabledValue(value) {
-    this._enabled = value;
-  }
-  enable() {
-    this._enabled = true;
-  }
-  disable() {
-    this._enabled = false;
-  }
-  isEnabled() {
-    return this._enabled;
-  }
-  toggle() {
-    this._enabled = !this._enabled;
-  }
+    _enabled = true;
+    constructor(enabled) {
+        if (typeof enabled === 'boolean') {
+            this._enabled = enabled;
+        }
+    }
+    setEnabledValue(value) {
+        this._enabled = value;
+    }
+    enable() {
+        this._enabled = true;
+    }
+    disable() {
+        this._enabled = false;
+    }
+    isEnabled() {
+        return this._enabled;
+    }
+    toggle() {
+        this._enabled = !this._enabled;
+    }
 }
+exports.Enabler = Enabler;
 /*
  * Classes for enabler exporters, allowing enable/disable toggling of exporters at runtime.
  *
@@ -46,130 +47,200 @@ class Enabler {
  * disabled, the reader's `collect` method is not called at all, saving additional resources compared to disabling the exporter.
  *
  */
-exports.Enabler = Enabler;
 class EnablerSpanExporter extends Enabler {
-  constructor(exporter) {
-    super();
-    this.exporter = exporter;
-  }
-  export(spans, resultCallback) {
-    if (this.isEnabled()) {
-      this.exporter.export(spans, resultCallback);
-    }
-  }
-  shutdown() {
-    return this.exporter.shutdown();
-  }
-  forceFlush() {
-    if (typeof this.exporter.forceFlush === 'function') {
-      return this.exporter.forceFlush();
-    }
-    return Promise.resolve();
-  }
+    exporter;
+    constructor(exporter) {
+        super();
+        this.exporter = exporter;
+    }
+    export(spans, resultCallback) {
+        if (this.isEnabled()) {
+            this.exporter.export(spans, resultCallback);
+        }
+    }
+    shutdown() {
+        return this.exporter.shutdown();
+    }
+    forceFlush() {
+        if (typeof this.exporter.forceFlush === 'function') {
+            return this.exporter.forceFlush();
+        }
+        return Promise.resolve();
+    }
 }
 exports.EnablerSpanExporter = EnablerSpanExporter;
 class EnablerLogExporter extends Enabler {
-  constructor(exporter) {
-    super();
-    this.exporter = exporter;
-  }
-  export(logs, resultCallback) {
-    if (this.isEnabled()) {
-      this.exporter.export(logs, resultCallback);
-    }
-  }
-  shutdown() {
-    return this.exporter.shutdown();
-  }
+    exporter;
+    constructor(exporter) {
+        super();
+        this.exporter = exporter;
+    }
+    export(logs, resultCallback) {
+        if (this.isEnabled()) {
+            this.exporter.export(logs, resultCallback);
+        }
+    }
+    shutdown() {
+        return this.exporter.shutdown();
+    }
 }
 exports.EnablerLogExporter = EnablerLogExporter;
 class EnablerMultiExporter extends Enabler {
-  constructor(exporters) {
-    super();
-    this._exporters = [];
-    if (exporters && Array.isArray(exporters)) {
-      this._exporters = exporters;
-    }
-  }
-  addExporters(exporter) {
-    if (!this._exporters) {
-      this._exporters = [];
-    }
-    if (Array.isArray(exporter)) {
-      this._exporters.push(...exporter);
-    } else {
-      this._exporters.push(exporter);
-    }
-  }
+    _exporters = [];
+    constructor(exporters) {
+        super();
+        if (exporters && Array.isArray(exporters)) {
+            this._exporters = exporters;
+        }
+    }
+    addExporters(exporter) {
+        if (!this._exporters) {
+            this._exporters = [];
+        }
+        if (Array.isArray(exporter)) {
+            this._exporters.push(...exporter);
+        }
+        else {
+            this._exporters.push(exporter);
+        }
+    }
+    clearExporters() {
+        this._exporters = [];
+    }
 }
 class EnablerMultiSpanExporter extends EnablerMultiExporter {
-  export(spans, resultCallback) {
-    _logger.default.debug(`EnablerMultiSpanExporter.export called with ${spans.length} spans, exporters: ${this._exporters?.length ?? 0}, enabled: ${this.isEnabled()}`);
-    if (this.isEnabled() && this._exporters) {
-      this._exporters.forEach(exporter => exporter.export(spans, resultCallback));
-    }
-  }
-  async shutdown() {
-    if (this._exporters) {
-      await Promise.all(this._exporters.map(exporter => exporter.shutdown()));
-    }
-    return;
-  }
+    export(spans, resultCallback) {
+        logger_js_1.default.debug(`EnablerMultiSpanExporter.export called with ${spans.length} spans, exporters: ${this._exporters?.length ?? 0}, enabled: ${this.isEnabled()}`);
+        if (!this.isEnabled() || !this._exporters || this._exporters.length === 0) {
+            resultCallback({ code: core_1.ExportResultCode.SUCCESS });
+            return;
+        }
+        let pending = this._exporters.length;
+        let failed = false;
+        let firstError;
+        this._exporters.forEach((exporter) => {
+            try {
+                exporter.export(spans, (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() {
+        if (this._exporters) {
+            await Promise.all(this._exporters.map((exporter) => exporter.shutdown()));
+        }
+        return;
+    }
 }
 exports.EnablerMultiSpanExporter = EnablerMultiSpanExporter;
 class EnablerMultiLogExporter extends EnablerMultiExporter {
-  export(logs, resultCallback) {
-    if (this.isEnabled() && this._exporters) {
-      this._exporters.forEach(exporter => exporter.export(logs, resultCallback));
+    export(logs, resultCallback) {
+        if (!this.isEnabled() || !this._exporters || this._exporters.length === 0) {
+            resultCallback({ code: core_1.ExportResultCode.SUCCESS });
+            return;
+        }
+        let pending = this._exporters.length;
+        let failed = false;
+        let firstError;
+        this._exporters.forEach((exporter) => {
+            try {
+                exporter.export(logs, (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() {
-    if (this._exporters) {
-      await Promise.all(this._exporters.map(exporter => exporter.shutdown()));
+    async shutdown() {
+        if (this._exporters) {
+            await Promise.all(this._exporters.map((exporter) => exporter.shutdown()));
+        }
+        return;
     }
-    return;
-  }
 }
 exports.EnablerMultiLogExporter = EnablerMultiLogExporter;
 class EnablerMetricReader extends Enabler {
-  constructor(reader) {
-    super();
-    this.reader = reader;
-  }
-  forceFlush(options) {
-    if (this.isEnabled()) {
-      return this.reader.forceFlush(options);
-    }
-    return Promise.resolve();
-  }
-  setMetricProducer(metricProducer) {
-    if (this.isEnabled()) {
-      this.reader.setMetricProducer(metricProducer);
-    }
-  }
-  selectAggregation(instrumentType) {
-    return this.reader.selectAggregation(instrumentType);
-  }
-  selectAggregationTemporality(instrumentType) {
-    return this.reader.selectAggregationTemporality(instrumentType);
-  }
-  selectCardinalityLimit(instrumentType) {
-    return this.reader.selectCardinalityLimit(instrumentType);
-  }
-  async collect(options) {
-    if (this.isEnabled()) {
-      return await this.reader.collect(options);
-    }
-    return {
-      resourceMetrics: {
-        resource: (0, _resources.resourceFromAttributes)({}),
-        scopeMetrics: []
-      },
-      errors: []
-    };
-  }
-  shutdown(options) {
-    return this.reader.shutdown(options);
-  }
+    reader;
+    constructor(reader) {
+        super();
+        this.reader = reader;
+    }
+    forceFlush(options) {
+        if (this.isEnabled()) {
+            return this.reader.forceFlush(options);
+        }
+        return Promise.resolve();
+    }
+    setMetricProducer(metricProducer) {
+        if (this.isEnabled()) {
+            this.reader.setMetricProducer(metricProducer);
+        }
+    }
+    selectAggregation(instrumentType) {
+        return this.reader.selectAggregation(instrumentType);
+    }
+    selectAggregationTemporality(instrumentType) {
+        return this.reader.selectAggregationTemporality(instrumentType);
+    }
+    selectCardinalityLimit(instrumentType) {
+        return this.reader.selectCardinalityLimit(instrumentType);
+    }
+    async collect(options) {
+        if (this.isEnabled()) {
+            return await this.reader.collect(options);
+        }
+        return {
+            resourceMetrics: {
+                resource: (0, resources_1.resourceFromAttributes)({}),
+                scopeMetrics: [],
+            },
+            errors: [],
+        };
+    }
+    shutdown(options) {
+        return this.reader.shutdown(options);
+    }
 }
-exports.EnablerMetricReader = EnablerMetricReader;
+exports.EnablerMetricReader = EnablerMetricReader;

package/dist/cjs/telemetry/initializeTelemetry.cjs

@@ -1,98 +1,42 @@
 "use strict";
-
-var _instrumentationHttp = require("@opentelemetry/instrumentation-http");
-var _logger = _interopRequireDefault(require("../utils/logger.cjs"));
-var _instrumentation = require("@opentelemetry/instrumentation");
-var _telemetryRegistry = require("./telemetryRegistry.cjs");
-var _sdkTraceNode = require("@opentelemetry/sdk-trace-node");
-var _apiLogs = require("@opentelemetry/api-logs");
-var _sdkLogs = require("@opentelemetry/sdk-logs");
-var _bootConfig = require("../config/bootConfig.cjs");
-var _util = _interopRequireDefault(require("util"));
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const logger_js_1 = __importDefault(require("../utils/logger.cjs"));
+const bootConfig_js_1 = require("../config/bootConfig.cjs");
+const instrumentation_http_1 = require("@opentelemetry/instrumentation-http");
+const telemetryRegistry_js_1 = require("./telemetryRegistry.cjs");
+const logsInstrumentation_js_1 = require("./custom-implementations/instrumentations/logsInstrumentation.cjs");
+const instrumentation_runtime_node_1 = require("@opentelemetry/instrumentation-runtime-node");
 // THIS INSTRUMENTATIONS NEED TO BE LOADED BEFORE ANYTHING ELSE
 // They use monkey-patching to instrument the HTTP server and client.
 // THIS FILE MUST BE CALLED BEFORE ANYTHING ELSE
-if (_bootConfig.bootEnvVariables.OASTLM_BOOT_MODULE_DISABLED) {
-  _logger.default.info('🚫 OASTLM module is disabled, Providers not initialized.');
-} else {
-  _logger.default.info('🚀 Initializing Open Telemetry');
-  initializeTraces();
-  initializeMetrics();
-  initializeLogs();
-  (0, _instrumentation.registerInstrumentations)({
-    instrumentations: [new _instrumentationHttp.HttpInstrumentation()
-    // new ExpressInstrumentation(),
-    ]
-  });
+if (bootConfig_js_1.bootEnvVariables.OASTLM_BOOT_MODULE_DISABLED) {
+    logger_js_1.default.info('🚫 OASTLM module is disabled, Auto Instrumentations not initialized.');
 }
-function initializeTraces() {
-  _logger.default.info('📊 Initializing TracerProvider');
-  const tracerProvider = new _sdkTraceNode.NodeTracerProvider({
-    resource: _telemetryRegistry.oasTelemetryResource,
-    spanProcessors: [_telemetryRegistry.dynamicMultiSpanProcessor]
-  });
-  tracerProvider.register();
-}
-function initializeLogs() {
-  _logger.default.info('📜 Initializing LoggerProvider');
-  // Create and configure LoggerProvider
-  const loggerProvider = new _sdkLogs.LoggerProvider({
-    resource: _telemetryRegistry.oasTelemetryResource,
-    processors: [_telemetryRegistry.dynamicMultiLogProcessor]
-  });
-  // Get a logger instance
-  const loggerInstance = loggerProvider.getLogger('oas-telemetry'); // Use loggerProvider to get the logger
-  Object.keys(_telemetryRegistry.originalConsoleMethods).forEach(method => {
-    // @ts-expect-error yes
-    console[method] = (...args) => {
-      const severity = getSeverityForMethod(method);
-      loggerInstance.emit({
-        severityNumber: severity.number,
-        severityText: severity.text,
-        body: _util.default.format(...args),
-        attributes: {
-          'source': `console.${method}`,
-          "library": "oas-telemetry"
+else {
+    if (!(0, telemetryRegistry_js_1.isBootInitialized)()) {
+        // Only HTTP instrumentation por ahora
+        const httpInstrumentation = new instrumentation_http_1.HttpInstrumentation({
+            // Ignore internal telemetry routes
+            ignoreIncomingRequestHook: (req) => {
+                const url = req.url || '';
+                const path = url.split('?')[0]; // Remove query params
+                // Ignore all baseUrl routes except those with 'generate'
+                if (path.includes(bootConfig_js_1.bootEnvVariables.OASTLM_BOOT_BASE_URL)) {
+                    return !path.includes('generate');
+                }
+                return false;
+            }
+        });
+        if (!bootConfig_js_1.bootEnvVariables.OASTLM_BOOT_AUTOINSTRUMENTATIONS_NODE_DISABLED) {
+            telemetryRegistry_js_1.instrumentations.push(httpInstrumentation, new instrumentation_runtime_node_1.RuntimeNodeInstrumentation());
         }
-      });
-      // @ts-expect-error yes
-      _telemetryRegistry.originalConsoleMethods[method](...args);
-    };
-  });
-}
-function initializeMetrics() {
-  _logger.default.info('📈 Initializing MeterProvider');
-  // WARN: Default PeriodicExportingMetricReader is added post initialization (see telemetryConfigurator.ts)
-  // The in memory exporter is added by default to that reader. More readers are allowed to be added dynamically
+        if (!bootConfig_js_1.bootEnvVariables.OASTLM_BOOT_AUTOINSTRUMENTATIONS_LOGS_DISABLED) {
+            telemetryRegistry_js_1.instrumentations.push(new logsInstrumentation_js_1.LogsInstrumentation());
+        }
+        (0, telemetryRegistry_js_1.setBootInitialized)(true);
+        logger_js_1.default.info('✅ Auto Instrumentations created successfully');
+    }
 }
-function getSeverityForMethod(method) {
-  switch (method) {
-    case "log":
-    case "info":
-      return {
-        number: _apiLogs.SeverityNumber.INFO,
-        text: "INFO"
-      };
-    case "debug":
-      return {
-        number: _apiLogs.SeverityNumber.DEBUG,
-        text: "DEBUG"
-      };
-    case "warn":
-      return {
-        number: _apiLogs.SeverityNumber.WARN,
-        text: "WARN"
-      };
-    case "error":
-      return {
-        number: _apiLogs.SeverityNumber.ERROR,
-        text: "ERROR"
-      };
-    default:
-      return {
-        number: _apiLogs.SeverityNumber.INFO,
-        text: "INFO"
-      };
-  }
-}

package/dist/cjs/telemetry/persistence/DiskImporter.cjs

@@ -0,0 +1,85 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiskImporter = void 0;
+const promises_1 = __importDefault(require("fs/promises"));
+const logger_js_1 = __importDefault(require("../../utils/logger.cjs"));
+const DiskUtils_js_1 = require("./DiskUtils.cjs");
+class DiskImporter {
+    directoryPath;
+    segmentPrefix;
+    importBatchSize;
+    constructor(options) {
+        this.directoryPath = options.directoryPath;
+        this.segmentPrefix = options.segmentPrefix || DiskUtils_js_1.DEFAULT_SEGMENT_PREFIX;
+        this.importBatchSize = options.importBatchSize || 500;
+    }
+    async import(onBatch) {
+        const stats = {
+            segmentFilesRead: 0,
+            importedRecords: 0,
+            failedFrames: 0,
+        };
+        const segments = await (0, DiskUtils_js_1.listSegments)(this.directoryPath, this.segmentPrefix);
+        if (!segments.length) {
+            return stats;
+        }
+        const importBuffer = [];
+        const flushImportBuffer = async () => {
+            if (!importBuffer.length)
+                return;
+            const batch = importBuffer.splice(0, importBuffer.length);
+            await onBatch(batch);
+            stats.importedRecords += batch.length;
+        };
+        for (const segment of segments) {
+            stats.segmentFilesRead += 1;
+            let fileBuffer;
+            try {
+                fileBuffer = await promises_1.default.readFile(segment.filePath);
+            }
+            catch (error) {
+                logger_js_1.default.warn(`[DiskImporter] Could not read segment ${segment.filePath}: ${error?.message || error}`);
+                continue;
+            }
+            let offset = 0;
+            while (offset + 4 <= fileBuffer.length) {
+                const frameLength = fileBuffer.readUInt32LE(offset);
+                offset += 4;
+                if (frameLength <= 0) {
+                    stats.failedFrames += 1;
+                    logger_js_1.default.warn(`[DiskImporter] Invalid frame length in ${segment.filePath}; stopping segment parse.`);
+                    break;
+                }
+                if (offset + frameLength > fileBuffer.length) {
+                    stats.failedFrames += 1;
+                    logger_js_1.default.warn(`[DiskImporter] Truncated frame in ${segment.filePath}; stopping segment parse.`);
+                    break;
+                }
+                const framePayload = fileBuffer.subarray(offset, offset + frameLength);
+                offset += frameLength;
+                try {
+                    const decodedSpans = (0, DiskUtils_js_1.decodeRecordBatchFrame)(framePayload);
+                    importBuffer.push(...decodedSpans);
+                    while (importBuffer.length >= this.importBatchSize) {
+                        const batch = importBuffer.splice(0, this.importBatchSize);
+                        await onBatch(batch);
+                        stats.importedRecords += batch.length;
+                    }
+                }
+                catch (error) {
+                    stats.failedFrames += 1;
+                    logger_js_1.default.warn(`[DiskImporter] Failed to decode frame from ${segment.filePath}: ${error?.message || error}`);
+                }
+            }
+            if (offset !== fileBuffer.length) {
+                logger_js_1.default.warn(`[DiskImporter] Segment ${segment.filePath} has trailing or incomplete bytes.`);
+            }
+        }
+        await flushImportBuffer();
+        return stats;
+    }
+}
+exports.DiskImporter = DiskImporter;

package/dist/cjs/telemetry/persistence/DiskUtils.cjs

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_MAX_SEGMENT_BYTES = exports.SEGMENT_EXT = exports.DEFAULT_SEGMENT_PREFIX = void 0;
+exports.getSegmentName = getSegmentName;
+exports.listSegments = listSegments;
+exports.encodeRecordBatchFrame = encodeRecordBatchFrame;
+exports.decodeRecordBatchFrame = decodeRecordBatchFrame;
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const zlib_1 = require("zlib");
+exports.DEFAULT_SEGMENT_PREFIX = 'traces';
+exports.SEGMENT_EXT = '.oastlm';
+exports.DEFAULT_MAX_SEGMENT_BYTES = 8 * 1024 * 1024;
+function getSegmentName(index, prefix = exports.DEFAULT_SEGMENT_PREFIX) {
+    return `${prefix}-${index.toString().padStart(6, '0')}${exports.SEGMENT_EXT}`;
+}
+async function listSegments(directoryPath, prefix = exports.DEFAULT_SEGMENT_PREFIX) {
+    try {
+        const files = await promises_1.default.readdir(directoryPath);
+        const regex = new RegExp(`^${prefix}-(\\d{6})${exports.SEGMENT_EXT.replace('.', '\\.')}$`);
+        return files
+            .map((name) => {
+            const match = name.match(regex);
+            if (!match)
+                return null;
+            const index = Number.parseInt(match[1], 10);
+            return { index, filePath: path_1.default.join(directoryPath, name) };
+        })
+            .filter((value) => value !== null)
+            .sort((a, b) => a.index - b.index);
+    }
+    catch (error) {
+        if (error?.code === 'ENOENT') {
+            return [];
+        }
+        throw error;
+    }
+}
+function encodeRecordBatchFrame(records) {
+    const lineDelimitedJson = records.map((record) => JSON.stringify(record)).join('\n') + '\n';
+    const compressed = (0, zlib_1.gzipSync)(Buffer.from(lineDelimitedJson, 'utf-8'));
+    const frame = Buffer.allocUnsafe(4 + compressed.length);
+    frame.writeUInt32LE(compressed.length, 0);
+    compressed.copy(frame, 4);
+    return frame;
+}
+function decodeRecordBatchFrame(framePayload) {
+    const decompressed = (0, zlib_1.gunzipSync)(framePayload).toString('utf-8');
+    const lines = decompressed.split('\n').filter((line) => line.trim().length > 0);
+    return lines.map((line, index) => {
+        try {
+            return JSON.parse(line);
+        }
+        catch {
+            throw new Error(`Invalid JSON line at index ${index}`);
+        }
+    });
+}