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

package/dist/cjs/tlm-auth/authMiddleware.cjs

@@ -1,33 +1,28 @@
 "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.getAuthMiddleware = getAuthMiddleware;
-var _jsonwebtoken = _interopRequireDefault(require("jsonwebtoken"));
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
 function getAuthMiddleware(oasTlmConfig) {
-  return function authMiddleware(req, res, next) {
-    if (!oasTlmConfig.auth.enabled) {
-      return next();
-    }
-    const token = req.cookies["oas-tlm-access-token"];
-    if (!token) {
-      res.status(401).json({
-        valid: false,
-        message: "No access token"
-      });
-      return;
-    }
-    try {
-      const payload = _jsonwebtoken.default.verify(token, oasTlmConfig.auth.jwtSecret);
-      if (payload.type !== "access") throw new Error("Invalid token type");
-      return next();
-    } catch {
-      res.status(401).json({
-        valid: false,
-        message: "Invalid access token"
-      });
-    }
-  };
-}
+    return function authMiddleware(req, res, next) {
+        if (!oasTlmConfig.auth.enabled) {
+            return next();
+        }
+        const token = req.cookies["oas-tlm-access-token"];
+        if (!token) {
+            res.status(401).json({ valid: false, message: "No access token" });
+            return;
+        }
+        try {
+            const payload = jsonwebtoken_1.default.verify(token, oasTlmConfig.auth.jwtSecret);
+            if (payload.type !== "access")
+                throw new Error("Invalid token type");
+            return next();
+        }
+        catch {
+            res.status(401).json({ valid: false, message: "Invalid access token" });
+        }
+    };
+}

package/dist/cjs/tlm-auth/authRoutes.cjs

@@ -1,17 +1,14 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.getAuthRoutes = void 0;
-var _express = require("express");
-var _authController = require("./authController.cjs");
-const getAuthRoutes = oasTlmConfig => {
-  const router = (0, _express.Router)();
-  router.post('/login', (0, _authController.getLogin)(oasTlmConfig));
-  router.post('/refresh', (0, _authController.getRefresh)(oasTlmConfig));
-  router.post('/logout', (0, _authController.getLogout)(oasTlmConfig));
-  router.get('/enabled', (0, _authController.getAuthEnabled)(oasTlmConfig));
-  return router;
+const express_1 = require("express");
+const authController_js_1 = require("./authController.cjs");
+const getAuthRoutes = (oasTlmConfig) => {
+    const router = (0, express_1.Router)();
+    router.post('/login', (0, authController_js_1.getLogin)(oasTlmConfig));
+    router.post('/refresh', (0, authController_js_1.getRefresh)(oasTlmConfig));
+    router.post('/logout', (0, authController_js_1.getLogout)(oasTlmConfig));
+    router.get('/enabled', (0, authController_js_1.getAuthEnabled)(oasTlmConfig));
+    return router;
 };
-exports.getAuthRoutes = getAuthRoutes;
+exports.getAuthRoutes = getAuthRoutes;

package/dist/cjs/tlm-log/logController.cjs

@@ -1,142 +1,161 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.stopLogs = exports.statusLogs = exports.startLogs = exports.setLogRetentionTime = exports.resetLogs = exports.insertLogsToDb = exports.getLogRetentionTime = exports.findLogs = void 0;
-var _telemetryRegistry = require("../telemetry/telemetryRegistry.cjs");
-var _logger = _interopRequireDefault(require("../utils/logger.cjs"));
-var _regexUtils = require("../utils/regexUtils.cjs");
-const _excluded = ["_id"];
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-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; }
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exportLogs = exports.getLogRetentionTime = exports.setLogRetentionTime = exports.statusLogs = exports.stopLogs = exports.startLogs = exports.importLogs = exports.insertLogsToDb = exports.resetLogs = exports.findLogs = void 0;
+const telemetryRegistry_js_1 = require("../telemetry/telemetryRegistry.cjs");
+const logger_js_1 = __importDefault(require("../utils/logger.cjs"));
+const regexUtils_js_1 = require("../utils/regexUtils.cjs");
+const logService_js_1 = require("./logService.cjs");
+const zlib_1 = require("zlib");
 const findLogs = async (req, res) => {
-  const body = req.body || {};
-  const messageSearch = body.textSearch || null;
-  const findQuery = body.query || {};
-  const limit = parseInt(body.limit) || 50;
-  const sortOrder = body.sort || null;
-  _logger.default.debug(`findLogs called with query: ${JSON.stringify(findQuery)} and search: ${messageSearch}`, {
-    depth: 3
-  });
-  let processedQuery;
-  try {
-    processedQuery = (0, _regexUtils.convertRegexRecursively)(findQuery);
-  } catch (error) {
-    _logger.default.error(error.message);
-    res.status(400).send({
-      error: error.message
-    });
-    return; // Exit if invalid regex was encountered
-  }
-  try {
-    // Use findConfig object
-    const findConfig = {
-      query: processedQuery,
-      messageSearch,
-      limit,
-      sortOrder
-    };
-    const docs = await _telemetryRegistry.inMemoryDbLogExporter.find(findConfig);
-    res.send({
-      items: docs
-    });
-  } catch (err) {
-    _logger.default.error(err);
-    res.status(500).send({
-      error: 'Failed to find logs',
-      details: err.message
-    });
-  }
+    const body = req.body || {};
+    const messageSearch = body.textSearch || null;
+    const findQuery = body.query || {};
+    const limit = parseInt(body.limit) || 50;
+    const sortOrder = body.sort || null;
+    logger_js_1.default.debug(`findLogs called with query: ${JSON.stringify(findQuery)} and search: ${messageSearch}`, { depth: 3 });
+    let processedQuery;
+    try {
+        processedQuery = (0, regexUtils_js_1.convertRegexRecursively)(findQuery);
+    }
+    catch (error) {
+        logger_js_1.default.error(error.message);
+        res.status(400).send({ error: error.message });
+        return; // Exit if invalid regex was encountered
+    }
+    try {
+        // Use findConfig object
+        const findConfig = {
+            query: processedQuery,
+            messageSearch,
+            limit,
+            sortOrder
+        };
+        const docs = await telemetryRegistry_js_1.inMemoryDbLogExporter.find(findConfig);
+        res.send({
+            logsCount: docs.length,
+            logs: docs,
+        });
+    }
+    catch (err) {
+        logger_js_1.default.error(err);
+        res.status(500).send({ error: 'Failed to find logs', details: err.message });
+    }
 };
 exports.findLogs = findLogs;
 const resetLogs = (req, res) => {
-  _telemetryRegistry.inMemoryDbLogExporter.reset();
-  res.send('Logs reset');
+    telemetryRegistry_js_1.inMemoryDbLogExporter.reset();
+    res.send('Logs reset');
 };
 exports.resetLogs = resetLogs;
 const insertLogsToDb = async (req, res) => {
-  const jsonContent = req.body.logs;
-  const resetData = req.query.reset === 'true';
-  if (!Array.isArray(jsonContent)) {
-    res.status(400).send({
-      error: 'Invalid data format.'
-    });
-    return;
-  }
-  const cleanedLogs = jsonContent.map(log => {
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    const {
-        _id
-      } = log,
-      rest = _objectWithoutProperties(log, _excluded); // Remove _id if it exists
-    return rest; // Return the cleaned log object
-  });
-  try {
-    let message = '';
-    if (resetData) {
-      _telemetryRegistry.inMemoryDbLogExporter.reset();
-      message += 'Logs Database reset. ';
+    const jsonContent = (req.body || {}).logs;
+    const resetData = req.query.reset === 'true';
+    if (!Array.isArray(jsonContent)) {
+        res.status(400).send({ error: 'Invalid data format.' });
+        return;
     }
-    await new Promise((resolve, reject) => {
-      _telemetryRegistry.inMemoryDbLogExporter.insert(cleanedLogs, (err, newDocs) => {
-        if (err) {
-          _logger.default.error('Error inserting logs:', err);
-          return reject(err);
+    const cleanedLogs = (0, logService_js_1.sanitizeLogRecords)(jsonContent);
+    try {
+        let message = '';
+        await (0, logService_js_1.importLogsToMemory)(cleanedLogs, { reset: resetData });
+        if (resetData) {
+            message += 'Logs Database reset. ';
         }
-        resolve(newDocs);
-      });
-    });
-    message += `Inserted ${cleanedLogs.length} logs.`;
-    res.send({
-      message,
-      InsertedLogsCount: cleanedLogs.length
-    });
-  } catch (err) {
-    _logger.default.error(err);
-    res.status(500).send({
-      error: 'Failed to reset and insert data',
-      details: err.message
-    });
-  }
+        message += `Inserted ${cleanedLogs.length} logs.`;
+        res.send({ message, InsertedLogsCount: cleanedLogs.length });
+    }
+    catch (err) {
+        logger_js_1.default.error(err);
+        res.status(500).send({ error: 'Failed to reset and insert data', details: err.message });
+    }
 };
 exports.insertLogsToDb = insertLogsToDb;
+const importLogs = async (req, res) => {
+    const resetData = req.query.reset === 'true';
+    const body = req.body || {};
+    const importedLogs = Array.isArray(body) ? body : body.logs;
+    try {
+        if (!Array.isArray(importedLogs)) {
+            res.status(400).send({ error: 'Invalid data format. Expected an array in request body or body.logs.' });
+            return;
+        }
+        const cleanedLogs = (0, logService_js_1.sanitizeLogRecords)(importedLogs);
+        let message = '';
+        await (0, logService_js_1.importLogsToMemory)(cleanedLogs, { reset: resetData });
+        if (resetData) {
+            message += 'Logs Database reset. ';
+        }
+        message += `Imported ${cleanedLogs.length} logs.`;
+        res.send({ message, ImportedLogsCount: cleanedLogs.length });
+    }
+    catch (err) {
+        logger_js_1.default.error('Import failed:', err);
+        res.status(400).send({ error: 'Failed to import logs', details: err.message });
+    }
+};
+exports.importLogs = importLogs;
 const startLogs = (req, res) => {
-  _telemetryRegistry.inMemoryDbLogExporter.enable();
-  res.send('Log collection started');
+    telemetryRegistry_js_1.inMemoryDbLogExporter.enable();
+    res.send('Log collection started');
 };
 exports.startLogs = startLogs;
 const stopLogs = (req, res) => {
-  _telemetryRegistry.inMemoryDbLogExporter.disable();
-  res.send('Log collection stopped');
+    telemetryRegistry_js_1.inMemoryDbLogExporter.disable();
+    res.send('Log collection stopped');
 };
 exports.stopLogs = stopLogs;
 const statusLogs = (req, res) => {
-  const isRunning = _telemetryRegistry.inMemoryDbLogExporter.isEnabled() || false;
-  res.send({
-    active: isRunning
-  });
+    const isRunning = telemetryRegistry_js_1.inMemoryDbLogExporter.isEnabled() || false;
+    res.send({ active: isRunning });
 };
 exports.statusLogs = statusLogs;
 const setLogRetentionTime = (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.inMemoryDbLogExporter.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.inMemoryDbLogExporter.retentionTimeInSeconds = retentionTimeInSeconds;
+    res.send({ message: `Retention time set to ${retentionTimeInSeconds} seconds.` });
 };
 exports.setLogRetentionTime = setLogRetentionTime;
 const getLogRetentionTime = (req, res) => {
-  const retentionTimeInSeconds = _telemetryRegistry.inMemoryDbLogExporter.retentionTimeInSeconds || 0;
-  res.send({
-    retentionTimeInSeconds: retentionTimeInSeconds
-  });
+    const retentionTimeInSeconds = telemetryRegistry_js_1.inMemoryDbLogExporter.retentionTimeInSeconds || 0;
+    res.send({ retentionTimeInSeconds: retentionTimeInSeconds });
+};
+exports.getLogRetentionTime = getLogRetentionTime;
+const exportLogs = async (req, res) => {
+    try {
+        const findConfig = {
+            query: {},
+            messageSearch: null,
+            sortOrder: { timestamp: -1 }
+        };
+        const docs = await telemetryRegistry_js_1.inMemoryDbLogExporter.find(findConfig);
+        const responseBody = { logsCount: docs.length, logs: docs };
+        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="logs-${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) {
+        logger_js_1.default.error('Failed to export logs:', err);
+        res.status(500).send({ error: 'Failed to export logs', details: err.message });
+    }
 };
-exports.getLogRetentionTime = getLogRetentionTime;
+exports.exportLogs = exportLogs;

package/dist/cjs/tlm-log/logRoutes.cjs

@@ -1,24 +1,23 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.getLogRoutes = exports.default = void 0;
-var _express = require("express");
-var _logController = require("./logController.cjs");
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLogRoutes = void 0;
+const express_1 = require("express");
+const logController_js_1 = require("./logController.cjs");
 const getLogRoutes = () => {
-  const router = (0, _express.Router)();
-  // Logs Control
-  router.post('/start', _logController.startLogs);
-  router.post('/stop', _logController.stopLogs);
-  router.get('/status', _logController.statusLogs);
-  router.post('/reset', _logController.resetLogs);
-  router.post('/retention-time', _logController.setLogRetentionTime);
-  router.get('/retention-time', _logController.getLogRetentionTime);
-  router.get('/', _logController.findLogs);
-  router.post('/', _logController.insertLogsToDb);
-  router.post('/find', _logController.findLogs);
-  return router;
+    const router = (0, express_1.Router)();
+    // Logs Control
+    router.post('/start', logController_js_1.startLogs);
+    router.post('/stop', logController_js_1.stopLogs);
+    router.get('/status', logController_js_1.statusLogs);
+    router.post('/reset', logController_js_1.resetLogs);
+    router.post('/retention-time', logController_js_1.setLogRetentionTime);
+    router.get('/retention-time', logController_js_1.getLogRetentionTime);
+    router.get('/export', logController_js_1.exportLogs);
+    router.post('/import', logController_js_1.importLogs);
+    router.get('/', logController_js_1.findLogs);
+    router.post('/', logController_js_1.insertLogsToDb);
+    router.post('/find', logController_js_1.findLogs);
+    return router;
 };
 exports.getLogRoutes = getLogRoutes;
-var _default = exports.default = getLogRoutes;
+exports.default = exports.getLogRoutes;

package/dist/cjs/tlm-log/logService.cjs

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sanitizeLogRecords = sanitizeLogRecords;
+exports.importLogsToMemory = importLogsToMemory;
+const telemetryRegistry_js_1 = require("../telemetry/telemetryRegistry.cjs");
+function sanitizeLogRecords(records) {
+    return records.map((record) => {
+        const { _id, ...rest } = record;
+        return rest;
+    });
+}
+async function importLogsToMemory(records, options) {
+    if (options?.reset) {
+        telemetryRegistry_js_1.inMemoryDbLogExporter.reset();
+    }
+    if (!records.length) {
+        return 0;
+    }
+    await new Promise((resolve, reject) => {
+        telemetryRegistry_js_1.inMemoryDbLogExporter.insert(records, (err) => {
+            if (err) {
+                reject(err);
+                return;
+            }
+            resolve();
+        });
+    });
+    return records.length;
+}