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

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

@@ -1,146 +1,178 @@
 "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.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");
+const metricsService_js_1 = require("./metricsService.cjs");
+const zlib_1 = require("zlib");
+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' });
     }
-    const metrics = docs;
-    res.send({
-      metricsCount: metrics.length,
-      metrics: metrics
-    });
-  });
 };
-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;
+        }
+        const cleanedScopeMetrics = (0, metricsService_js_1.sanitizeMetricRecords)(scopeMetricsData);
+        let message = '';
+        (0, metricsService_js_1.importMetricsToMemory)(cleanedScopeMetrics, { reset: resetData, format });
+        if (resetData) {
+            message += 'Metrics Database reset. ';
         }
-        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
-    });
-  }
+        message += `Inserted ${cleanedScopeMetrics.length} scopeMetrics (format: ${format}).`;
+        res.send({
+            message,
+            scopeMetricsCount: cleanedScopeMetrics.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;
+const exportMetrics = (req, res) => {
+    try {
+        const response = telemetryRegistry_js_1.inMemoryDbMetricExporter.find({
+            format: 'raw'
+        });
+        const responseBody = {
+            format: 'raw',
+            scopeMetricsCount: response.results.length,
+            scopeMetrics: response.results,
+        };
+        const payload = JSON.stringify(responseBody);
+        const payloadSize = Buffer.byteLength(payload, 'utf-8');
+        const acceptsGzip = String(req.headers['accept-encoding'] || '').includes('gzip');
+        const timestamp = new Date().toISOString().slice(0, 19).replace(/[-T:]/g, '');
+        res.setHeader('Content-Type', 'application/json');
+        res.setHeader('Content-Disposition', `attachment; filename="metrics-${timestamp}.json"`);
+        res.setHeader('Vary', 'Accept-Encoding');
+        if (acceptsGzip && payloadSize > 64 * 1024) {
+            const compressed = (0, zlib_1.gzipSync)(payload);
+            res.setHeader('Content-Encoding', 'gzip');
+            res.setHeader('Content-Length', compressed.length.toString());
+            res.end(compressed);
+            return;
+        }
+        res.setHeader('Content-Length', payloadSize.toString());
+        res.end(payload);
+    }
+    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 body = req.body || {};
+    const format = (body.format || req.query.format || 'raw');
+    const importedScopeMetrics = Array.isArray(body) ? body : body.scopeMetrics;
+    try {
+        if (!Array.isArray(importedScopeMetrics)) {
+            res.status(400).send({ error: 'Invalid data format. Expected an array in request body or body.scopeMetrics.' });
+            return;
+        }
+        const cleanedMetrics = (0, metricsService_js_1.sanitizeMetricRecords)(importedScopeMetrics);
+        (0, metricsService_js_1.importMetricsToMemory)(cleanedMetrics, { reset: resetData, format });
+        let message = '';
+        if (resetData) {
+            message += 'Metrics Database reset. ';
+        }
+        message += `Imported ${cleanedMetrics.length} metrics (format: ${format}).`;
+        res.send({ message, ImportedMetricsCount: cleanedMetrics.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,26 @@
 "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);
+    router.post('/import', 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;

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

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sanitizeMetricRecords = sanitizeMetricRecords;
+exports.importMetricsToMemory = importMetricsToMemory;
+const telemetryRegistry_js_1 = require("../telemetry/telemetryRegistry.cjs");
+function sanitizeMetricRecords(records) {
+    return records.map((record) => {
+        const { _id, ...rest } = record;
+        return rest;
+    });
+}
+function importMetricsToMemory(records, options) {
+    if (options?.reset) {
+        telemetryRegistry_js_1.inMemoryDbMetricExporter.reset();
+    }
+    if (!records.length) {
+        return 0;
+    }
+    if ((options?.format || 'raw') === 'otel') {
+        telemetryRegistry_js_1.inMemoryDbMetricExporter.insertOtel(records);
+    }
+    else {
+        telemetryRegistry_js_1.inMemoryDbMetricExporter.insertRaw(records);
+    }
+    return records.length;
+}