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

package/dist/cjs/routesManager.cjs

@@ -1,76 +1,68 @@
 "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.configureRoutes = void 0;
-var _express = require("express");
-var _logger = _interopRequireDefault(require("./utils/logger.cjs"));
-var _cors = _interopRequireDefault(require("cors"));
-var _traceRoutes = require("./tlm-trace/traceRoutes.cjs");
-var _metricsRoutes = require("./tlm-metric/metricsRoutes.cjs");
-var _logRoutes = require("./tlm-log/logRoutes.cjs");
-var _cookieParser = _interopRequireDefault(require("cookie-parser"));
-var _authRoutes = require("./tlm-auth/authRoutes.cjs");
-var _uiRoutes = require("./tlm-ui/uiRoutes.cjs");
-var _authMiddleware = require("./tlm-auth/authMiddleware.cjs");
-var _utilRoutes = require("./tlm-util/utilRoutes.cjs");
-var _aiRoutes = require("./tlm-ai/aiRoutes.cjs");
-var _bootConfig = require("./config/bootConfig.cjs");
-var _pluginRoutes = require("./tlm-plugin/pluginRoutes.cjs");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const express_1 = require("express");
+const logger_js_1 = __importDefault(require("./utils/logger.cjs"));
+const cors_1 = __importDefault(require("cors"));
+const traceRoutes_js_1 = require("./tlm-trace/traceRoutes.cjs");
+const metricsRoutes_js_1 = require("./tlm-metric/metricsRoutes.cjs");
+const logRoutes_js_1 = require("./tlm-log/logRoutes.cjs");
+const cookie_parser_1 = __importDefault(require("cookie-parser"));
+const authRoutes_js_1 = require("./tlm-auth/authRoutes.cjs");
+const uiRoutes_js_1 = require("./tlm-ui/uiRoutes.cjs");
+const authMiddleware_js_1 = require("./tlm-auth/authMiddleware.cjs");
+const utilRoutes_js_1 = require("./tlm-util/utilRoutes.cjs");
+const aiRoutes_js_1 = require("./tlm-ai/aiRoutes.cjs");
+const bootConfig_js_1 = require("./config/bootConfig.cjs");
+const pluginRoutes_js_1 = require("./tlm-plugin/pluginRoutes.cjs");
 const configureRoutes = (router, oasTlmConfig) => {
-  if (_bootConfig.bootEnvVariables.OASTLM_BOOT_ENV === 'development') {
-    _logger.default.info("Running in development mode, enabling CORS for all origins");
-    router.use((0, _cors.default)({
-      origin: (origin, callback) => {
-        if (!origin || /^http:\/\/localhost:\d+$/.test(origin)) {
-          callback(null, true);
-        } else {
-          callback(new Error('Not allowed by CORS'));
-        }
-      },
-      credentials: true
-    }));
-  }
-  const telemetryBaseUrl = oasTlmConfig.general.baseUrl;
-  // Sub-router for all telemetry endpoints
-  const telemetryRouter = (0, _express.Router)();
-  // Body parser for JSON requests
-  telemetryRouter.use((req, res, next) => {
-    if (req.body !== undefined) {
-      return next(); // Already parsed, no need to parse again.
+    if (!oasTlmConfig.general.spec && !oasTlmConfig.general.specFileName) {
+        logger_js_1.default.warn("No spec provided, endpoint filtering will not be available. Please provide either `spec` or `specFileName` in the configuration.");
     }
-    return (0, _express.json)({
-      limit: '10mb'
-    })(req, res, next);
-  });
-  telemetryRouter.get('/health', (_req, res) => {
-    res.status(200).send({
-      status: 'OK'
+    if (bootConfig_js_1.bootEnvVariables.OASTLM_BOOT_ENV === 'development') {
+        logger_js_1.default.info("Running in development mode, enabling CORS for all origins");
+        router.use((0, cors_1.default)({
+            origin: true,
+            credentials: true
+        }));
+    }
+    const telemetryBaseUrl = bootConfig_js_1.bootEnvVariables.OASTLM_BOOT_BASE_URL;
+    // Sub-router for all telemetry endpoints
+    const telemetryRouter = (0, express_1.Router)();
+    // Body parser for JSON requests
+    telemetryRouter.use((req, res, next) => {
+        if (req.body !== undefined) {
+            return next(); // Already parsed, no need to parse again.
+        }
+        return (0, express_1.json)({ limit: '500mb' })(req, res, next);
     });
-  });
-  // Redirect to the UI when accessing the base URL
-  telemetryRouter.get('/', (req, res) => {
-    res.redirect(`${telemetryBaseUrl}/oas-telemetry-ui/`);
-  });
-  // WARNING: This path must be the same as the one used in the UI package App.tsx "oas-telemetry-ui"
-  telemetryRouter.use("/oas-telemetry-ui", (0, _uiRoutes.getUIRoutes)());
-  telemetryRouter.use("/utils", (0, _utilRoutes.getUtilsRoutes)(oasTlmConfig));
-  // Auth routes must be registered. If authentication is not enabled, all requests will be allowed.
-  // Frontend will use these endpoints;
-  telemetryRouter.use((0, _cookieParser.default)());
-  // Refresh token uses /auth/refresh path, careful if you change it
-  telemetryRouter.use('/auth', (0, _authRoutes.getAuthRoutes)(oasTlmConfig));
-  telemetryRouter.use((0, _authMiddleware.getAuthMiddleware)(oasTlmConfig));
-  telemetryRouter.use("/traces", (0, _traceRoutes.getTraceRoutes)());
-  telemetryRouter.use("/metrics", (0, _metricsRoutes.getMetricsRoutes)());
-  telemetryRouter.use("/logs", (0, _logRoutes.getLogRoutes)());
-  if (oasTlmConfig.ai.openAIKey) {
-    telemetryRouter.use("/ai", (0, _aiRoutes.getAIRoutes)(oasTlmConfig));
-  }
-  telemetryRouter.use("/plugins", (0, _pluginRoutes.getPluginRoutes)());
-  // Mount the telemetryRouter under telemetryBaseUrl
-  router.use(telemetryBaseUrl, telemetryRouter);
+    telemetryRouter.get('/health', (_req, res) => {
+        res.status(200).send({ status: 'OK' });
+    });
+    // Redirect to the UI when accessing the base URL
+    telemetryRouter.get('/', (req, res) => {
+        res.redirect(`${telemetryBaseUrl}/oas-telemetry-ui/`);
+    });
+    // WARNING: This path must be the same as the one used in the UI package App.tsx "oas-telemetry-ui"
+    telemetryRouter.use("/oas-telemetry-ui", (0, uiRoutes_js_1.getUIRoutes)());
+    telemetryRouter.use("/utils", (0, utilRoutes_js_1.getUtilsRoutes)(oasTlmConfig));
+    // Auth routes must be registered. If authentication is not enabled, all requests will be allowed.
+    // Frontend will use these endpoints;
+    telemetryRouter.use((0, cookie_parser_1.default)());
+    // Refresh token uses /auth/refresh path, careful if you change it
+    telemetryRouter.use('/auth', (0, authRoutes_js_1.getAuthRoutes)(oasTlmConfig));
+    telemetryRouter.use((0, authMiddleware_js_1.getAuthMiddleware)(oasTlmConfig));
+    telemetryRouter.use("/traces", (0, traceRoutes_js_1.getTraceRoutes)());
+    telemetryRouter.use("/metrics", (0, metricsRoutes_js_1.getMetricsRoutes)());
+    telemetryRouter.use("/logs", (0, logRoutes_js_1.getLogRoutes)());
+    if (oasTlmConfig.ai.openAIKey) {
+        telemetryRouter.use("/ai", (0, aiRoutes_js_1.getAIRoutes)(oasTlmConfig));
+    }
+    telemetryRouter.use("/plugins", (0, pluginRoutes_js_1.getPluginRoutes)());
+    // Mount the telemetryRouter under telemetryBaseUrl
+    router.use(telemetryBaseUrl, telemetryRouter);
 };
-exports.configureRoutes = configureRoutes;
+exports.configureRoutes = configureRoutes;

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

@@ -0,0 +1,121 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiskLogExporter = void 0;
+const core_1 = require("@opentelemetry/core");
+const circular_js_1 = require("../utils/circular.cjs");
+const wrappers_js_1 = require("../wrappers.cjs");
+const DiskWriter_js_1 = require("../../persistence/DiskWriter.cjs");
+const logger_js_1 = __importDefault(require("../../../utils/logger.cjs"));
+class DiskLogExporter extends wrappers_js_1.Enabler {
+    writer;
+    flushIntervalMs;
+    batchSize;
+    queuedLogs = [];
+    flushTimer = null;
+    flushing = false;
+    constructor(options) {
+        super();
+        this.flushIntervalMs = options.flushIntervalMs || 1000;
+        this.batchSize = options.batchSize || 500;
+        this.writer = new DiskWriter_js_1.DiskWriter({
+            directoryPath: options.directoryPath,
+            segmentPrefix: 'logs',
+            maxSegmentBytes: options.maxSegmentBytes,
+        });
+    }
+    export(logs, resultCallback) {
+        if (!this.isEnabled()) {
+            resultCallback({ code: core_1.ExportResultCode.SUCCESS });
+            return;
+        }
+        try {
+            const serializableLogs = logs
+                .map((logRecord) => this.formatLogRecord(logRecord))
+                .map((log) => (0, circular_js_1.removeCircularRefs)(log))
+                .map((log) => (0, circular_js_1.applyNesting)(log));
+            if (serializableLogs.length > 0) {
+                this.queuedLogs.push(...serializableLogs);
+                if (this.queuedLogs.length >= this.batchSize) {
+                    void this.flushPending();
+                }
+                else {
+                    this.scheduleFlush();
+                }
+            }
+            resultCallback({ code: core_1.ExportResultCode.SUCCESS });
+        }
+        catch (error) {
+            logger_js_1.default.error(`[DiskLogExporter] Failed to queue logs: ${error?.message || error}`);
+            resultCallback({
+                code: core_1.ExportResultCode.FAILED,
+                error: error instanceof Error ? error : new Error(String(error)),
+            });
+        }
+    }
+    async shutdown() {
+        this.disable();
+        if (this.flushTimer) {
+            clearTimeout(this.flushTimer);
+            this.flushTimer = null;
+        }
+        await this.flushPending(true);
+        await this.writer.flush();
+    }
+    async forceFlush() {
+        await this.flushPending(true);
+        await this.writer.flush();
+    }
+    scheduleFlush() {
+        if (this.flushTimer)
+            return;
+        this.flushTimer = setTimeout(() => {
+            this.flushTimer = null;
+            void this.flushPending(true);
+        }, this.flushIntervalMs);
+    }
+    async flushPending(forceAll = false) {
+        if (this.flushing)
+            return;
+        if (this.queuedLogs.length === 0)
+            return;
+        this.flushing = true;
+        try {
+            while (this.queuedLogs.length > 0) {
+                if (!forceAll && this.queuedLogs.length < this.batchSize) {
+                    this.scheduleFlush();
+                    break;
+                }
+                const size = forceAll ? this.queuedLogs.length : this.batchSize;
+                const batch = this.queuedLogs.splice(0, size);
+                await this.writer.appendRecords(batch);
+            }
+        }
+        catch (error) {
+            logger_js_1.default.error(`[DiskLogExporter] Failed writing logs to disk: ${error?.message || error}`);
+        }
+        finally {
+            this.flushing = false;
+        }
+    }
+    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,
+        };
+    }
+}
+exports.DiskLogExporter = DiskLogExporter;

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

@@ -0,0 +1,101 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiskMetricExporter = void 0;
+const core_1 = require("@opentelemetry/core");
+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 DiskWriter_js_1 = require("../../persistence/DiskWriter.cjs");
+class DiskMetricExporter extends wrappers_js_1.Enabler {
+    writer;
+    flushIntervalMs;
+    batchSize;
+    queuedScopeMetrics = [];
+    flushTimer = null;
+    flushing = false;
+    constructor(options) {
+        super();
+        this.flushIntervalMs = options.flushIntervalMs || 1000;
+        this.batchSize = options.batchSize || 500;
+        this.writer = new DiskWriter_js_1.DiskWriter({
+            directoryPath: options.directoryPath,
+            segmentPrefix: 'metrics',
+            maxSegmentBytes: options.maxSegmentBytes,
+        });
+    }
+    export(resourceMetrics, resultCallback) {
+        if (!this.isEnabled()) {
+            resultCallback({ code: core_1.ExportResultCode.SUCCESS });
+            return;
+        }
+        try {
+            const scopeMetrics = (0, circular_js_1.removeCircularRefs)(resourceMetrics.scopeMetrics || []);
+            if (Array.isArray(scopeMetrics) && scopeMetrics.length > 0) {
+                this.queuedScopeMetrics.push(...scopeMetrics);
+                if (this.queuedScopeMetrics.length >= this.batchSize) {
+                    void this.flushPending();
+                }
+                else {
+                    this.scheduleFlush();
+                }
+            }
+            resultCallback({ code: core_1.ExportResultCode.SUCCESS });
+        }
+        catch (error) {
+            logger_js_1.default.error(`[DiskMetricExporter] Failed to queue scope metrics: ${error?.message || error}`);
+            resultCallback({
+                code: core_1.ExportResultCode.FAILED,
+                error: error instanceof Error ? error : new Error(String(error)),
+            });
+        }
+    }
+    async shutdown() {
+        this.disable();
+        if (this.flushTimer) {
+            clearTimeout(this.flushTimer);
+            this.flushTimer = null;
+        }
+        await this.flushPending(true);
+        await this.writer.flush();
+    }
+    async forceFlush() {
+        await this.flushPending(true);
+        await this.writer.flush();
+    }
+    scheduleFlush() {
+        if (this.flushTimer)
+            return;
+        this.flushTimer = setTimeout(() => {
+            this.flushTimer = null;
+            void this.flushPending(true);
+        }, this.flushIntervalMs);
+    }
+    async flushPending(forceAll = false) {
+        if (this.flushing)
+            return;
+        if (this.queuedScopeMetrics.length === 0)
+            return;
+        this.flushing = true;
+        try {
+            while (this.queuedScopeMetrics.length > 0) {
+                if (!forceAll && this.queuedScopeMetrics.length < this.batchSize) {
+                    this.scheduleFlush();
+                    break;
+                }
+                const size = forceAll ? this.queuedScopeMetrics.length : this.batchSize;
+                const batch = this.queuedScopeMetrics.splice(0, size);
+                await this.writer.appendRecords(batch);
+            }
+        }
+        catch (error) {
+            logger_js_1.default.error(`[DiskMetricExporter] Failed writing metrics to disk: ${error?.message || error}`);
+        }
+        finally {
+            this.flushing = false;
+        }
+    }
+}
+exports.DiskMetricExporter = DiskMetricExporter;

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

@@ -0,0 +1,103 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiskTraceExporter = void 0;
+const core_1 = require("@opentelemetry/core");
+const logger_js_1 = __importDefault(require("../../../utils/logger.cjs"));
+const circular_js_1 = require("../utils/circular.cjs");
+const DiskWriter_js_1 = require("../../persistence/DiskWriter.cjs");
+const wrappers_js_1 = require("../wrappers.cjs");
+class DiskTraceExporter extends wrappers_js_1.Enabler {
+    writer;
+    flushIntervalMs;
+    batchSize;
+    queuedSpans = [];
+    flushTimer = null;
+    flushing = false;
+    constructor(options) {
+        super();
+        this.flushIntervalMs = options.flushIntervalMs || 1000;
+        this.batchSize = options.batchSize || 500;
+        this.writer = new DiskWriter_js_1.DiskWriter({
+            directoryPath: options.directoryPath,
+            segmentPrefix: 'traces',
+            maxSegmentBytes: options.maxSegmentBytes,
+        });
+    }
+    export(spans, resultCallback) {
+        if (!this.isEnabled()) {
+            resultCallback({ code: core_1.ExportResultCode.SUCCESS });
+            return;
+        }
+        try {
+            const serializableSpans = spans
+                .map((span) => (0, circular_js_1.removeCircularRefs)(span))
+                .map((span) => (0, circular_js_1.applyNesting)(span));
+            if (serializableSpans.length > 0) {
+                this.queuedSpans.push(...serializableSpans);
+                if (this.queuedSpans.length >= this.batchSize) {
+                    void this.flushPending();
+                }
+                else {
+                    this.scheduleFlush();
+                }
+            }
+            resultCallback({ code: core_1.ExportResultCode.SUCCESS });
+        }
+        catch (error) {
+            logger_js_1.default.error(`[DiskTraceExporter] Failed to queue spans: ${error?.message || error}`);
+            resultCallback({
+                code: core_1.ExportResultCode.FAILED,
+                error: error instanceof Error ? error : new Error(String(error)),
+            });
+        }
+    }
+    async shutdown() {
+        this.disable();
+        if (this.flushTimer) {
+            clearTimeout(this.flushTimer);
+            this.flushTimer = null;
+        }
+        await this.flushPending(true);
+        await this.writer.flush();
+    }
+    async forceFlush() {
+        await this.flushPending(true);
+        await this.writer.flush();
+    }
+    scheduleFlush() {
+        if (this.flushTimer)
+            return;
+        this.flushTimer = setTimeout(() => {
+            this.flushTimer = null;
+            void this.flushPending(true);
+        }, this.flushIntervalMs);
+    }
+    async flushPending(forceAll = false) {
+        if (this.flushing)
+            return;
+        if (this.queuedSpans.length === 0)
+            return;
+        this.flushing = true;
+        try {
+            while (this.queuedSpans.length > 0) {
+                if (!forceAll && this.queuedSpans.length < this.batchSize) {
+                    this.scheduleFlush();
+                    break;
+                }
+                const size = forceAll ? this.queuedSpans.length : this.batchSize;
+                const batch = this.queuedSpans.splice(0, size);
+                await this.writer.appendRecords(batch);
+            }
+        }
+        catch (error) {
+            logger_js_1.default.error(`[DiskTraceExporter] Failed writing spans to disk: ${error?.message || error}`);
+        }
+        finally {
+            this.flushing = false;
+        }
+    }
+}
+exports.DiskTraceExporter = DiskTraceExporter;