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

package/dist/cjs/tlm-metric/metricsController.cjs

@@ -1,146 +1,236 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.stopMetrics = exports.statusMetrics = exports.startMetrics = exports.setMetricRetentionTime = exports.resetMetrics = exports.listMetrics = exports.insertMetricsToDb = exports.getMetricRetentionTime = exports.findMetrics = void 0;
-var _telemetryRegistry = require("../telemetry/telemetryRegistry.cjs");
-var _regexUtils = require("../utils/regexUtils.cjs");
-const _excluded = ["_id"];
-function _objectWithoutProperties(e, t) { if (null == e) return {}; var o, r, i = _objectWithoutPropertiesLoose(e, t); if (Object.getOwnPropertySymbols) { var n = Object.getOwnPropertySymbols(e); for (r = 0; r < n.length; r++) o = n[r], -1 === t.indexOf(o) && {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]); } return i; }
-function _objectWithoutPropertiesLoose(r, e) { if (null == r) return {}; var t = {}; for (var n in r) if ({}.hasOwnProperty.call(r, n)) { if (-1 !== e.indexOf(n)) continue; t[n] = r[n]; } return t; }
-const listMetrics = async (req, res) => {
-  try {
-    const metrics = _telemetryRegistry.inMemoryDbMetricExporter.getFinishedMetrics();
-    res.send({
-      metricsCount: metrics.length,
-      metrics: metrics
-    });
-  } catch (err) {
-    console.error(err);
-    res.status(500).send({
-      error: 'Failed to list metrics data'
-    });
-  }
-};
-exports.listMetrics = listMetrics;
-const findMetrics = (req, res) => {
-  const body = req.body;
-  const query = body?.query ? body.query : {};
-  let processedQuery;
-  try {
-    processedQuery = (0, _regexUtils.convertRegexRecursively)(query);
-  } catch (error) {
-    console.error(error.message);
-    res.status(400).send({
-      error: error.message
-    });
-    return; // Exit if invalid regex was encountered
-  }
-  _telemetryRegistry.inMemoryDbMetricExporter.find(processedQuery, (err, docs) => {
-    if (err) {
-      console.error(err);
-      res.status(404).send({
-        metricsCount: 0,
-        metrics: [],
-        error: err
-      });
-      return;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.importMetrics = exports.exportMetrics = exports.checkMetricsConsistency = exports.findMetrics = exports.getMetricRetentionTime = exports.setMetricRetentionTime = exports.statusMetrics = exports.stopMetrics = exports.startMetrics = exports.insertMetricsToDb = exports.resetMetrics = exports.getMetricsStats = void 0;
+const telemetryRegistry_js_1 = require("../telemetry/telemetryRegistry.cjs");
+/**
+ * Parse NDJSON import data
+ * Each line must be a valid JSON object
+ * @param body - Request body (raw string)
+ * @returns Array of metric objects
+ */
+function parseImportData(body) {
+    if (typeof body !== 'string') {
+        throw new Error('Import must be NDJSON format (plain text with one JSON object per line)');
     }
-    const metrics = docs;
-    res.send({
-      metricsCount: metrics.length,
-      metrics: metrics
+    const lines = body.split('\n').filter((line) => line.trim());
+    return lines.map((line, index) => {
+        try {
+            return JSON.parse(line);
+        }
+        catch {
+            console.error(`Failed to parse NDJSON line ${index + 1}: ${line}`);
+            throw new Error(`Invalid JSON on line ${index + 1}`);
+        }
     });
-  });
+}
+const getMetricsStats = async (req, res) => {
+    try {
+        const stats = telemetryRegistry_js_1.inMemoryDbMetricExporter.getStats();
+        res.send(stats);
+    }
+    catch (err) {
+        console.error(err);
+        res.status(500).send({ error: 'Failed to get metrics stats' });
+    }
 };
-exports.findMetrics = findMetrics;
+exports.getMetricsStats = getMetricsStats;
 const resetMetrics = (req, res) => {
-  _telemetryRegistry.inMemoryDbMetricExporter.reset();
-  res.send('Metrics reset');
+    telemetryRegistry_js_1.inMemoryDbMetricExporter.reset();
+    res.send('Metrics reset');
 };
 exports.resetMetrics = resetMetrics;
 const insertMetricsToDb = async (req, res) => {
-  const jsonContent = req.body.metrics;
-  const resetData = req.query.reset === 'true';
-  if (!Array.isArray(jsonContent)) {
-    res.status(400).send({
-      error: 'Invalid data format.'
-    });
-    return;
-  }
-  const cleanedMetrics = jsonContent.map(metric => {
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    const {
-        _id
-      } = metric,
-      rest = _objectWithoutProperties(metric, _excluded); // Remove _id if it exists
-    return rest; // Return the cleaned metric object
-  });
-  try {
-    let message = '';
-    if (resetData) {
-      _telemetryRegistry.inMemoryDbMetricExporter.reset();
-      message += 'Metrics Database reset. ';
-    }
-    await new Promise((resolve, reject) => {
-      _telemetryRegistry.inMemoryDbMetricExporter.insert(cleanedMetrics, (err, newDocs) => {
-        if (err) {
-          console.error('Error inserting metrics:', err);
-          return reject(err);
+    try {
+        const scopeMetricsData = (req.body || {}).scopeMetrics;
+        const resetData = req.query.reset === 'true';
+        const format = (req.body.format || req.query.format || 'raw');
+        if (!Array.isArray(scopeMetricsData)) {
+            res.status(400).send({ error: 'Invalid data format. Expected array in body.scopeMetrics' });
+            return;
         }
-        resolve(newDocs);
-      });
-    });
-    message += `Inserted ${cleanedMetrics.length} metrics.`;
-    res.send({
-      message,
-      InsertedMetricsCount: cleanedMetrics.length
-    });
-  } catch (err) {
-    console.error(err);
-    res.status(500).send({
-      error: 'Failed to reset and insert data',
-      details: err.message
-    });
-  }
+        let message = '';
+        if (resetData) {
+            telemetryRegistry_js_1.inMemoryDbMetricExporter.reset();
+            message += 'Metrics Database reset. ';
+        }
+        // Store samples
+        if (format === 'otel')
+            telemetryRegistry_js_1.inMemoryDbMetricExporter.insertOtel(scopeMetricsData);
+        else
+            telemetryRegistry_js_1.inMemoryDbMetricExporter.insertRaw(scopeMetricsData);
+        message += `Inserted ${scopeMetricsData.length} scopeMetrics (format: ${format}).`;
+        res.send({
+            message,
+            scopeMetricsCount: scopeMetricsData.length,
+            format
+        });
+    }
+    catch (err) {
+        console.error(err);
+        res.status(500).send({ error: 'Failed to reset and insert data', details: err.message });
+    }
 };
 exports.insertMetricsToDb = insertMetricsToDb;
 const startMetrics = (req, res) => {
-  _telemetryRegistry.inMemoryDbMetricExporter.enable();
-  res.send('Metrics collection started');
+    telemetryRegistry_js_1.inMemoryDbMetricExporter.enable();
+    res.send('Metrics collection started');
 };
 exports.startMetrics = startMetrics;
 const stopMetrics = (req, res) => {
-  _telemetryRegistry.inMemoryDbMetricExporter.disable();
-  res.send('Metrics collection stopped');
+    telemetryRegistry_js_1.inMemoryDbMetricExporter.disable();
+    res.send('Metrics collection stopped');
 };
 exports.stopMetrics = stopMetrics;
 const statusMetrics = (req, res) => {
-  const isRunning = _telemetryRegistry.inMemoryDbMetricExporter.isEnabled() || false;
-  res.send({
-    active: isRunning
-  });
+    const isRunning = telemetryRegistry_js_1.inMemoryDbMetricExporter.isEnabled() || false;
+    res.send({ active: isRunning });
 };
 exports.statusMetrics = statusMetrics;
 const setMetricRetentionTime = (req, res) => {
-  const retentionTimeInSeconds = req.body.retentionTimeInSeconds;
-  if (typeof retentionTimeInSeconds !== 'number' || retentionTimeInSeconds <= 0) {
-    res.status(400).send({
-      error: 'Invalid retention time. Must be a positive number.'
-    });
-    return;
-  }
-  _telemetryRegistry.inMemoryDbMetricExporter.retentionTimeInSeconds = retentionTimeInSeconds;
-  res.send({
-    message: `Retention time set to ${retentionTimeInSeconds} seconds.`
-  });
+    const retentionTimeInSeconds = (req.body || {}).retentionTimeInSeconds;
+    if (typeof retentionTimeInSeconds !== 'number' || retentionTimeInSeconds <= 0) {
+        res.status(400).send({ error: 'Invalid retention time. Must be a positive number.' });
+        return;
+    }
+    telemetryRegistry_js_1.inMemoryDbMetricExporter.retentionTimeInSeconds = retentionTimeInSeconds;
+    res.send({ message: `Retention time set to ${retentionTimeInSeconds} seconds.` });
 };
 exports.setMetricRetentionTime = setMetricRetentionTime;
 const getMetricRetentionTime = (req, res) => {
-  const retentionTimeInSeconds = _telemetryRegistry.inMemoryDbMetricExporter.retentionTimeInSeconds || 0;
-  res.send({
-    retentionTimeInSeconds: retentionTimeInSeconds
-  });
+    const retentionTimeInSeconds = telemetryRegistry_js_1.inMemoryDbMetricExporter.retentionTimeInSeconds || 0;
+    res.send({ retentionTimeInSeconds: retentionTimeInSeconds });
+};
+exports.getMetricRetentionTime = getMetricRetentionTime;
+/**
+ * Find metrics by scope+metric queries with filters (POST /metrics/find or GET /metrics)
+ * All parameters are optional:
+ * - If scopeMetrics is not provided or empty, returns all metrics
+ * - If startTime/endTime not provided, returns all available data
+ * - format can be 'raw' (default) or 'otel'
+ */
+const findMetrics = async (req, res) => {
+    try {
+        const { scopeMetrics, from, to, format } = req.body || {};
+        // Validate scopeMetrics structure if provided
+        if (scopeMetrics && Array.isArray(scopeMetrics)) {
+            for (const query of scopeMetrics) {
+                if (!query.scope || !query.scope.name || !query.descriptor || !query.descriptor.name) {
+                    res.status(400).json({
+                        error: 'Each query must have scope.name and descriptor.name defined'
+                    });
+                    return;
+                }
+            }
+        }
+        // Execute query
+        const response = telemetryRegistry_js_1.inMemoryDbMetricExporter.find({
+            scopeMetrics: scopeMetrics && scopeMetrics.length > 0 ? scopeMetrics : undefined,
+            from,
+            to,
+            format: format || 'raw'
+        });
+        res.json({
+            format: format || 'raw',
+            scopeMetricsCount: response.results.length,
+            scopeMetrics: response.results,
+        });
+    }
+    catch (err) {
+        console.error(err);
+        res.status(500).json({ error: 'Failed to find metrics' });
+    }
+};
+exports.findMetrics = findMetrics;
+/**
+ * Check data consistency between rawDataDB and queried data
+ * Compares raw exports with findMetrics(format=otel) without filters
+ */
+const checkMetricsConsistency = async (req, res) => {
+    try {
+        // Get raw exported data
+        const rawData = telemetryRegistry_js_1.inMemoryDbMetricExporter.rawDataDB;
+        // Query all data with OTEL format
+        const response = telemetryRegistry_js_1.inMemoryDbMetricExporter.find({
+            format: 'otel'
+        });
+        const queriedData = response.results;
+        // Compare counts
+        const statusCheck = rawData.length === queriedData.length;
+        res.json({
+            statusCheck,
+            raw: rawData,
+            queried: queriedData
+        });
+    }
+    catch (err) {
+        console.error(err);
+        res.status(500).json({ error: 'Failed to check metrics consistency' });
+    }
+};
+exports.checkMetricsConsistency = checkMetricsConsistency;
+const exportMetrics = (req, res) => {
+    try {
+        const ndjsonData = telemetryRegistry_js_1.inMemoryDbMetricExporter.exportToNDJSON();
+        const timestamp = new Date().toISOString().slice(0, 19).replace(/[-T:]/g, '');
+        res.setHeader('Content-Type', 'application/x-ndjson');
+        res.setHeader('Content-Disposition', `attachment; filename="metrics-${timestamp}.ndjson"`);
+        res.setHeader('Transfer-Encoding', 'chunked');
+        res.write(ndjsonData);
+        res.end();
+    }
+    catch (err) {
+        console.error('Failed to export metrics:', err);
+        res.status(500).send({ error: 'Failed to export metrics', details: err.message });
+    }
+};
+exports.exportMetrics = exportMetrics;
+const importMetrics = async (req, res) => {
+    const resetData = req.query.reset === 'true';
+    const format = (req.query.format || 'raw');
+    try {
+        const ndjsonContent = req.body;
+        // Check if this is an exported NDJSON with headers (from our export function)
+        const firstLine = ndjsonContent.split('\n')[0];
+        let isExportedFormat = false;
+        try {
+            const firstObj = JSON.parse(firstLine);
+            isExportedFormat = firstObj.type === 'header';
+        }
+        catch {
+            // Not a valid JSON line, continue with normal parsing
+        }
+        let message = '';
+        if (resetData) {
+            telemetryRegistry_js_1.inMemoryDbMetricExporter.reset();
+            message += 'Metrics Database reset. ';
+        }
+        // If it's an exported format with headers/metadata, use direct NDJSON import
+        if (isExportedFormat) {
+            telemetryRegistry_js_1.inMemoryDbMetricExporter.importFromNDJSON(ndjsonContent);
+            message += `Imported metrics from exported NDJSON format.`;
+            res.send({ message, format: 'exported-ndjson' });
+        }
+        else {
+            // Otherwise parse as raw metrics (queryresults or OTEL format)
+            const metricsArray = parseImportData(ndjsonContent);
+            if (metricsArray.length === 0) {
+                res.status(400).send({ error: 'No valid metrics found in import data' });
+                return;
+            }
+            // Use the same insert logic as insertMetricsToDb, respecting raw vs otel format
+            if (format === 'otel') {
+                telemetryRegistry_js_1.inMemoryDbMetricExporter.insertOtel(metricsArray);
+            }
+            else {
+                telemetryRegistry_js_1.inMemoryDbMetricExporter.insertRaw(metricsArray);
+            }
+            message += `Imported ${metricsArray.length} metrics (format: ${format}).`;
+            res.send({ message, ImportedMetricsCount: metricsArray.length, format });
+        }
+    }
+    catch (err) {
+        console.error('Import failed:', err);
+        res.status(400).send({ error: 'Failed to import metrics', details: err.message });
+    }
 };
-exports.getMetricRetentionTime = getMetricRetentionTime;
+exports.importMetrics = importMetrics;

package/dist/cjs/tlm-metric/metricsRoutes.cjs

@@ -1,24 +1,27 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.getMetricsRoutes = exports.default = void 0;
-var _express = require("express");
-var _metricsController = require("./metricsController.cjs");
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMetricsRoutes = void 0;
+const express_1 = require("express");
+const metricsController_js_1 = require("./metricsController.cjs");
 const getMetricsRoutes = () => {
-  const router = (0, _express.Router)();
-  // Metrics Control
-  router.post('/start', _metricsController.startMetrics);
-  router.post('/stop', _metricsController.stopMetrics);
-  router.get('/status', _metricsController.statusMetrics);
-  router.post('/reset', _metricsController.resetMetrics);
-  router.post('/retention-time', _metricsController.setMetricRetentionTime);
-  router.get('/retention-time', _metricsController.getMetricRetentionTime);
-  router.get('/', _metricsController.listMetrics);
-  router.post('/', _metricsController.insertMetricsToDb);
-  router.post('/find', _metricsController.findMetrics);
-  return router;
+    const router = (0, express_1.Router)();
+    // Metrics Control
+    router.post('/start', metricsController_js_1.startMetrics);
+    router.post('/stop', metricsController_js_1.stopMetrics);
+    router.get('/status', metricsController_js_1.statusMetrics);
+    router.post('/reset', metricsController_js_1.resetMetrics);
+    router.post('/retention-time', metricsController_js_1.setMetricRetentionTime);
+    router.get('/retention-time', metricsController_js_1.getMetricRetentionTime);
+    // Export/Import
+    router.get('/export', metricsController_js_1.exportMetrics);
+    // Use text middleware for import to handle NDJSON format
+    router.post('/import', (0, express_1.text)({ type: 'application/x-ndjson', limit: '500mb' }), metricsController_js_1.importMetrics);
+    // Query endpoints
+    router.post('/find', metricsController_js_1.findMetrics);
+    router.get('/stats', metricsController_js_1.getMetricsStats);
+    router.get('/', metricsController_js_1.findMetrics);
+    router.post('/', metricsController_js_1.insertMetricsToDb);
+    return router;
 };
 exports.getMetricsRoutes = getMetricsRoutes;
-var _default = exports.default = getMetricsRoutes;
+exports.default = exports.getMetricsRoutes;