@oas-tools/oas-telemetry 0.7.0-alpha.4 → 0.7.0

package/dist/esm/tlm-auth/authController.js

@@ -1,40 +1,82 @@
 import jwt from 'jsonwebtoken';
 import logger from '../utils/logger.js';
+function generateAccessToken(secret, expiresIn) {
+    return jwt.sign({ type: "access" }, secret, { expiresIn: Math.floor(expiresIn / 1000) });
+}
+function generateRefreshToken(secret, expiresIn) {
+    return jwt.sign({ type: "refresh" }, secret, { expiresIn: Math.floor(expiresIn / 1000) });
+}
 export const getLogin = (oasTlmConfig) => (req, res) => {
+    if (!oasTlmConfig.auth.enabled) {
+        res.status(200).json({ valid: true, message: "Auth disabled" });
+        return;
+    }
     try {
         const { password } = req.body;
         if (password === oasTlmConfig.auth.password) {
-            const options = {
-                maxAge: oasTlmConfig.auth.apiKeyMaxAge,
+            const accessToken = generateAccessToken(oasTlmConfig.auth.jwtSecret, oasTlmConfig.auth.accessTokenMaxAge);
+            const refreshToken = generateRefreshToken(oasTlmConfig.auth.jwtSecret, oasTlmConfig.auth.refreshTokenMaxAge);
+            res.cookie("oas-tlm-access-token", accessToken, {
+                maxAge: oasTlmConfig.auth.accessTokenMaxAge,
+                httpOnly: true,
+                secure: process.env.NODE_ENV === "production",
+                sameSite: "lax",
+                path: "/"
+            });
+            res.cookie("oas-tlm-refresh-token", refreshToken, {
+                maxAge: oasTlmConfig.auth.refreshTokenMaxAge,
                 httpOnly: true,
-                secure: true,
-                signed: false
-            };
-            const apiKey = jwt.sign({ password: oasTlmConfig.auth.password }, oasTlmConfig.auth.jwtSecret);
-            res.cookie('apiKey', apiKey, options);
-            res.status(200).json({ valid: true, message: 'API Key is valid' });
+                secure: process.env.NODE_ENV === "production",
+                sameSite: "lax",
+                path: oasTlmConfig.general.baseUrl + "/auth/refresh"
+            });
+            res.status(200).json({ valid: true, message: "Login successful" });
             return;
         }
-        res.status(400).json({ valid: false, message: 'Invalid API Key' });
+        res.status(400).json({ valid: false, message: "Invalid password" });
     }
     catch (error) {
-        logger.log("Error: ", error);
-        res.status(500).json({ valid: false, message: 'Internal server error' });
+        logger.error("Login error: ", error);
+        res.status(500).json({ valid: false, message: "Internal server error" });
     }
 };
 export const getLogout = (oasTlmConfig) => (req, res) => {
-    res.clearCookie('apiKey');
-    res.redirect(oasTlmConfig.general.baseUrl + oasTlmConfig.general.uiPath + '/login');
+    if (!oasTlmConfig.auth.enabled) {
+        res.status(200).json({ valid: true, message: "Auth disabled" });
+        return;
+    }
+    res.clearCookie('oas-tlm-access-token', { path: '/' });
+    res.clearCookie('oas-tlm-refresh-token', { path: oasTlmConfig.general.baseUrl + '/auth/refresh' });
+    res.status(200).json({ valid: true, message: "Logged out" });
 };
-export const getCheck = (oasTlmConfig) => (req, res) => {
-    if (!req.cookies.apiKey) {
-        res.status(200).json({ valid: false, message: 'API Key is invalid' });
+export const getRefresh = (oasTlmConfig) => (req, res) => {
+    if (!oasTlmConfig.auth.enabled) {
+        res.status(200).json({ valid: true, message: "Auth disabled" });
         return;
     }
-    const decoded = jwt.verify(req.cookies.apiKey, oasTlmConfig.auth.jwtSecret);
-    if (decoded.password === oasTlmConfig.auth.password) {
-        res.status(200).json({ valid: true, message: 'API Key is valid' });
+    const refreshToken = req.cookies["oas-tlm-refresh-token"];
+    if (!refreshToken) {
+        res.status(401).json({ valid: false, message: "No refresh token" });
         return;
     }
-    res.status(200).json({ valid: false, message: 'Invalid API Key' });
+    try {
+        const payload = jwt.verify(refreshToken, oasTlmConfig.auth.jwtSecret);
+        if (payload.type !== "refresh")
+            throw new Error("Invalid token type");
+        const accessToken = generateAccessToken(oasTlmConfig.auth.jwtSecret, oasTlmConfig.auth.accessTokenMaxAge);
+        res.cookie("oas-tlm-access-token", accessToken, {
+            maxAge: oasTlmConfig.auth.accessTokenMaxAge,
+            httpOnly: true,
+            secure: process.env.NODE_ENV === "production",
+            sameSite: "lax",
+            path: "/"
+        });
+        res.status(200).json({ valid: true, message: "Refreshed" });
+    }
+    catch {
+        res.status(401).json({ valid: false, message: "Invalid refresh token" });
+    }
+};
+export const getAuthEnabled = (oasTlmConfig) => (req, res) => {
+    res.status(200).json({ enabled: !!oasTlmConfig.auth.enabled });
 };

package/dist/esm/tlm-auth/authMiddleware.js

@@ -1,13 +1,22 @@
-import jwt from 'jsonwebtoken';
+import jwt from "jsonwebtoken";
 export function getAuthMiddleware(oasTlmConfig) {
     return function authMiddleware(req, res, next) {
-        const apiKey = req.cookies.apiKey;
-        if (apiKey) {
-            const decoded = jwt.verify(apiKey, oasTlmConfig.auth.jwtSecret);
-            if (decoded.password === oasTlmConfig.auth.password) {
-                return next();
-            }
-        }
-        res.status(401).redirect(oasTlmConfig.general.baseUrl + oasTlmConfig.general.uiPath + '/login');
+        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 = jwt.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/esm/tlm-auth/authRoutes.js

@@ -1,9 +1,10 @@
 import { Router } from 'express';
-import { getLogin, getLogout, getCheck } from './authController.js';
+import { getLogin, getLogout, getRefresh, getAuthEnabled } from './authController.js';
 export const getAuthRoutes = (oasTlmConfig) => {
     const router = Router();
     router.post('/login', getLogin(oasTlmConfig));
-    router.get('/logout', getLogout(oasTlmConfig));
-    router.get('/check', getCheck(oasTlmConfig));
+    router.post('/refresh', getRefresh(oasTlmConfig));
+    router.post('/logout', getLogout(oasTlmConfig));
+    router.get('/enabled', getAuthEnabled(oasTlmConfig));
     return router;
 };

package/dist/esm/tlm-log/logController.js

@@ -1,21 +1,13 @@
 import { inMemoryDbLogExporter } from '../telemetry/telemetryRegistry.js';
 import logger from '../utils/logger.js';
 import { convertRegexRecursively } from '../utils/regexUtils.js';
-export const listLogs = async (req, res) => {
-    try {
-        const logs = inMemoryDbLogExporter.getFinishedLogs();
-        res.send({ logsCount: logs.length, logs: logs });
-    }
-    catch (err) {
-        logger.error(err);
-        res.status(500).send({ error: 'Failed to list log data' });
-    }
-};
 export const findLogs = async (req, res) => {
-    const body = req.body;
-    const messageSearch = body?.textSearch || null; // Search term for MiniSearch
-    const findQuery = body?.query || {}; // Query for NeDB
-    logger.debug(`findLogs called with query: ${JSON.stringify(findQuery)} and search ${messageSearch}`, { depth: 3 });
+    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.debug(`findLogs called with query: ${JSON.stringify(findQuery)} and search: ${messageSearch}`, { depth: 3 });
     let processedQuery;
     try {
         processedQuery = convertRegexRecursively(findQuery);
@@ -26,15 +18,17 @@ export const findLogs = async (req, res) => {
         return; // Exit if invalid regex was encountered
     }
     try {
-        const results = await new Promise((resolve, reject) => {
-            inMemoryDbLogExporter.find(processedQuery, messageSearch, (err, docs) => {
-                if (err)
-                    return reject(err);
-                resolve(docs);
-            });
+        // Use findConfig object
+        const findConfig = {
+            query: processedQuery,
+            messageSearch,
+            limit,
+            sortOrder
+        };
+        const docs = await inMemoryDbLogExporter.find(findConfig);
+        res.send({
+            items: docs,
         });
-        const typedResults = results;
-        res.send({ logsCount: typedResults.length, logs: typedResults });
     }
     catch (err) {
         logger.error(err);
@@ -49,7 +43,7 @@ export 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. Expected an array of JSON objects.' });
+        res.status(400).send({ error: 'Invalid data format.' });
         return;
     }
     const cleanedLogs = jsonContent.map((log) => {
@@ -92,12 +86,16 @@ export const statusLogs = (req, res) => {
     const isRunning = inMemoryDbLogExporter.isEnabled() || false;
     res.send({ active: isRunning });
 };
-export const setRetentionTimeLogs = (req, res) => {
-    const retentionTime = req.body.retentionTime;
-    if (typeof retentionTime !== 'number' || retentionTime <= 0) {
+export 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;
     }
-    inMemoryDbLogExporter.retentionTimeInSeconds = retentionTime;
-    res.send({ message: `Retention time set to ${retentionTime} seconds.` });
+    inMemoryDbLogExporter.retentionTimeInSeconds = retentionTimeInSeconds;
+    res.send({ message: `Retention time set to ${retentionTimeInSeconds} seconds.` });
+};
+export const getLogRetentionTime = (req, res) => {
+    const retentionTimeInSeconds = inMemoryDbLogExporter.retentionTimeInSeconds || 0;
+    res.send({ retentionTimeInSeconds: retentionTimeInSeconds });
 };

package/dist/esm/tlm-log/logRoutes.js

@@ -1,5 +1,5 @@
 import { Router } from 'express';
-import { startLogs, stopLogs, statusLogs, resetLogs, listLogs, findLogs, insertLogsToDb, setRetentionTimeLogs } from './logController.js';
+import { startLogs, stopLogs, statusLogs, resetLogs, findLogs, insertLogsToDb, setLogRetentionTime, getLogRetentionTime } from './logController.js';
 export const getLogRoutes = () => {
     const router = Router();
     // Logs Control
@@ -7,8 +7,9 @@ export const getLogRoutes = () => {
     router.post('/stop', stopLogs);
     router.get('/status', statusLogs);
     router.post('/reset', resetLogs);
-    router.post('/retention-time', setRetentionTimeLogs);
-    router.get('/', listLogs);
+    router.post('/retention-time', setLogRetentionTime);
+    router.get('/retention-time', getLogRetentionTime);
+    router.get('/', findLogs);
     router.post('/', insertLogsToDb);
     router.post('/find', findLogs);
     return router;

package/dist/esm/tlm-metric/metricsController.js

@@ -40,7 +40,7 @@ export 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. Expected an array of JSON objects.' });
+        res.status(400).send({ error: 'Invalid data format.' });
         return;
     }
     const cleanedMetrics = jsonContent.map((metric) => {
@@ -83,12 +83,16 @@ export const statusMetrics = (req, res) => {
     const isRunning = inMemoryDbMetricExporter.isEnabled() || false;
     res.send({ active: isRunning });
 };
-export const setRetentionTimeMetrics = (req, res) => {
-    const retentionTime = req.body.retentionTime;
-    if (typeof retentionTime !== 'number' || retentionTime <= 0) {
+export 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;
     }
-    inMemoryDbMetricExporter.retentionTimeInSeconds = retentionTime;
-    res.send({ message: `Retention time set to ${retentionTime} seconds.` });
+    inMemoryDbMetricExporter.retentionTimeInSeconds = retentionTimeInSeconds;
+    res.send({ message: `Retention time set to ${retentionTimeInSeconds} seconds.` });
+};
+export const getMetricRetentionTime = (req, res) => {
+    const retentionTimeInSeconds = inMemoryDbMetricExporter.retentionTimeInSeconds || 0;
+    res.send({ retentionTimeInSeconds: retentionTimeInSeconds });
 };

package/dist/esm/tlm-metric/metricsRoutes.js

@@ -1,5 +1,5 @@
 import { Router } from 'express';
-import { listMetrics, findMetrics, resetMetrics, insertMetricsToDb, startMetrics, stopMetrics, statusMetrics, setRetentionTimeMetrics } from './metricsController.js';
+import { listMetrics, findMetrics, resetMetrics, insertMetricsToDb, startMetrics, stopMetrics, statusMetrics, setMetricRetentionTime, getMetricRetentionTime } from './metricsController.js';
 export const getMetricsRoutes = () => {
     const router = Router();
     // Metrics Control
@@ -7,7 +7,8 @@ export const getMetricsRoutes = () => {
     router.post('/stop', stopMetrics);
     router.get('/status', statusMetrics);
     router.post('/reset', resetMetrics);
-    router.post('/retention-time', setRetentionTimeMetrics);
+    router.post('/retention-time', setMetricRetentionTime);
+    router.get('/retention-time', getMetricRetentionTime);
     router.get('/', listMetrics);
     router.post('/', insertMetricsToDb);
     router.post('/find', findMetrics);

package/dist/esm/tlm-plugin/pluginController.js

@@ -5,7 +5,8 @@ import logger from "../utils/logger.js";
 import { pluginService } from "./pluginService.js";
 import { fileURLToPath } from "url";
 export const listPlugins = (req, res) => {
-    const plugins = pluginService.getPlugins();
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const plugins = pluginService.getPlugins().map(({ process, ...rest }) => rest);
     res.send({
         pluginsCount: plugins.length,
         plugins,

package/dist/esm/tlm-plugin/pluginProcess.js

@@ -14,12 +14,14 @@ process.on("message", async (msg) => {
             if (pluginResource.install && Array.isArray(pluginResource.install.dependencies) && pluginResource.install.dependencies.length > 0) {
                 log("Installing dependencies for plugin: " + pluginResource.name);
                 const dependenciesStatus = await installDependencies(pluginResource.install);
+                console.dir(dependenciesStatus);
                 if (!dependenciesStatus.success) {
+                    const detailsFailed = dependenciesStatus.details.filter(detail => detail.success === false);
                     if (pluginResource.install.ignoreErrors === true) {
-                        log(`Warning: Error installing dependencies: ${JSON.stringify(dependenciesStatus.details)}`);
+                        log(`Warning: Error installing dependencies: ${JSON.stringify(detailsFailed)}. Continuing as ignoreErrors is true.`);
                     }
                     else {
-                        process.send?.({ event: "error", error: `Error installing dependencies: ${JSON.stringify(dependenciesStatus.details)}` });
+                        process.send?.({ event: "error", error: `Error installing dependencies: ${JSON.stringify(detailsFailed)}` });
                         return;
                     }
                 }

package/dist/esm/tlm-plugin/pluginService.js

@@ -2,6 +2,7 @@ import logger from "../utils/logger.js";
 class PluginService {
     constructor() {
         this.plugins = [];
+        this.enabled = false;
     }
     getPlugins() {
         return this.plugins;
@@ -29,6 +30,8 @@ class PluginService {
         this.plugins = this.plugins.filter((p) => p.id !== pluginId);
     }
     broadcastToPlugins(type, payload) {
+        if (!this.enabled)
+            return;
         this.plugins.forEach((plugin, i) => {
             if (!plugin.active)
                 return;
@@ -65,6 +68,7 @@ class PluginService {
     }
     /**
      * Broadcast a new trace to all active plugins
+     * TODO: rename to span (trace is the whole trace, span is a single unit of work within a trace)
      */
     broadcastTrace(trace) {
         this.broadcastToPlugins("newTrace", trace);

package/dist/esm/tlm-trace/traceController.js

@@ -41,7 +41,7 @@ export const findTraces = (req, res) => {
     inMemoryDbSpanExporter.find(processedQuery, (err, docs) => {
         if (err) {
             console.error(err);
-            res.status(404).send({ spansCount: 0, spans: [], error: err.message });
+            res.status(400).send({ spansCount: 0, spans: [], error: err.message });
             return; // Exit the function to prevent further execution
         }
         const spans = docs;
@@ -52,7 +52,7 @@ export const insertTracesToDb = async (req, res) => {
     const jsonContent = req.body.spans;
     const resetData = req.query.reset === 'true';
     if (!Array.isArray(jsonContent)) {
-        res.status(400).send({ error: 'Invalid data format. Expected an array of JSON objects.' });
+        res.status(400).send({ error: 'Invalid data format.' });
         return;
     }
     const cleanedTraces = jsonContent.map((trace) => {
@@ -83,12 +83,16 @@ export const insertTracesToDb = async (req, res) => {
         res.status(500).send({ error: 'Failed to reset and insert data', details: err.message });
     }
 };
-export const setRetentionTimeTraces = (req, res) => {
-    const retentionTime = req.body.retentionTime;
-    if (typeof retentionTime !== 'number' || retentionTime <= 0) {
+export const setTraceRetentionTime = (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;
     }
-    inMemoryDbSpanExporter.retentionTimeInSeconds = retentionTime;
-    res.send({ message: `Retention time set to ${retentionTime} seconds.` });
+    inMemoryDbSpanExporter.retentionTimeInSeconds = retentionTimeInSeconds;
+    res.send({ message: `Retention time set to ${retentionTimeInSeconds} seconds.` });
+};
+export const getTraceRetentionTime = (req, res) => {
+    const retentionTimeInSeconds = inMemoryDbSpanExporter.retentionTimeInSeconds || 0;
+    res.send({ retentionTimeInSeconds: retentionTimeInSeconds });
 };

package/dist/esm/tlm-trace/traceRoutes.js

@@ -1,5 +1,5 @@
 import { Router } from 'express';
-import { startTraces, stopTraces, statusTraces, resetTraces, listTraces, findTraces, insertTracesToDb, setRetentionTimeTraces } from './traceController.js';
+import { startTraces, stopTraces, statusTraces, resetTraces, listTraces, findTraces, insertTracesToDb, setTraceRetentionTime, getTraceRetentionTime } from './traceController.js';
 export const getTraceRoutes = () => {
     const router = Router();
     // Telemetry Control
@@ -10,7 +10,8 @@ export const getTraceRoutes = () => {
     router.get('/', listTraces);
     router.post('/', insertTracesToDb);
     router.post('/find', findTraces);
-    router.post('/retention-time', setRetentionTimeTraces);
+    router.post('/retention-time', setTraceRetentionTime);
+    router.get('/retention-time', getTraceRetentionTime);
     return router;
 };
 export default getTraceRoutes;

package/dist/esm/tlm-util/utilController.js

@@ -2,6 +2,7 @@ import { readFileSync } from 'fs';
 import path from 'path';
 import yaml from 'js-yaml';
 import v8 from 'node:v8';
+import { fileURLToPath } from 'node:url';
 export const specLoader = (_req, res, oasTlmConfig) => {
     if (oasTlmConfig.general.specFileName) {
         try {
@@ -54,3 +55,24 @@ export const heapStats = (req, res) => {
     roundedHeapStats['units'] = 'MB';
     res.send(roundedHeapStats);
 };
+const isCjs = typeof __filename !== "undefined" && typeof __dirname !== "undefined";
+const __filenameUniversal = isCjs
+    ? __filename
+    : fileURLToPath(import.meta.url);
+const __dirnameUniversal = isCjs
+    ? __dirname
+    : path.dirname(__filenameUniversal);
+export const getOasTelemetrySpec = (_req, res) => {
+    try {
+        const specPath = path.join(__dirnameUniversal, '../docs/openapi.yaml');
+        const data = readFileSync(specPath, { encoding: 'utf8', flag: 'r' });
+        let json = data;
+        json = JSON.stringify(yaml.load(data), null, 2);
+        res.setHeader('Content-Type', 'application/json');
+        res.send(json);
+    }
+    catch (e) {
+        console.error(`ERROR loading OAS Telemetry OpenAPI spec file: ${e}`);
+        res.status(500).send(`ERROR loading OAS Telemetry OpenAPI spec file: ${e}`);
+    }
+};

package/dist/esm/tlm-util/utilRoutes.js

@@ -1,15 +1,33 @@
 import { Router } from 'express';
-import { specLoader, heapStats } from './utilController.js';
+import { specLoader, heapStats, getOasTelemetrySpec } from './utilController.js';
 export const getUtilsRoutes = (oasTlmConfig) => {
     const router = Router();
     router.get('/spec', (req, res) => specLoader(req, res, oasTlmConfig));
+    router.get('/oas-telemetry-spec', (req, res) => getOasTelemetrySpec(req, res));
     router.get('/heapStats', heapStats);
-    router.get('/generateLog', (req, res) => {
-        const log = req.query.log || 'Default log message';
-        console.log(log);
+    //This route is NOT ignored by the spanExporter (includes "generate")
+    router.post('/generate-log', async (req, res) => {
+        const log = req.body.log || 'Default log message';
+        const repeat = parseInt(req.body.repeat) || 1;
+        const method = req.body.method?.toLowerCase() || 'log';
+        if (!['log', 'warn', 'error', 'info', 'debug'].includes(method)) {
+            res.status(400).send({ error: 'Invalid method. Use log, warn, error, info, or debug.' });
+            return;
+        }
         res.send({ message: 'Log generated', log: log });
+        for (let i = 0; i < repeat; i++) {
+            console[method](log);
+            await new Promise(resolve => setTimeout(resolve, 50)); // Slight delay between logs
+        }
     });
-    router.get('/wait/:seconds?', async (req, res) => {
+    // This route is NOT ignored by the spanExporter (includes "generate")
+    router.post('/generate-mock-logs', async (req, res) => {
+        const count = parseInt(req.body.count) || 50;
+        generateMockLogs(count);
+        res.send({ message: 'Started generating mock logs' });
+    });
+    // This route is NOT ignored by the spanExporter
+    router.get('/generate-wait/:seconds?', async (req, res) => {
         const seconds = parseInt(req.params.seconds ?? "1", 10);
         const waitTime = isNaN(seconds) ? 1 : seconds;
         await new Promise(resolve => setTimeout(resolve, waitTime * 1000));
@@ -17,3 +35,20 @@ export const getUtilsRoutes = (oasTlmConfig) => {
     });
     return router;
 };
+const generateMockLogs = async (count) => {
+    const methodMessages = {
+        log: ['User logged in', 'Data fetched successfully'],
+        warn: ['Warning: Disk space low', 'Warning: High memory usage'],
+        error: ['Error connecting to database', 'Error: Invalid credentials'],
+        info: ['Info: Scheduled job started', 'Info: Configuration loaded'],
+        debug: ['Debugging mode enabled', 'Debug: Variable x = 42'],
+    };
+    const methods = Object.keys(methodMessages);
+    for (let i = 0; i < count; i++) {
+        await new Promise(resolve => setTimeout(resolve, 50)); // Slight delay between logs
+        const method = methods[Math.floor(Math.random() * methods.length)];
+        const messages = methodMessages[method];
+        const message = messages[Math.floor(Math.random() * messages.length)];
+        console[method](`[${new Date().toISOString()}][MOCK LOG][${method.toUpperCase()}] -${i + 1}- ${message}`);
+    }
+};

package/dist/esm/utils/logger.js

@@ -1,18 +1,41 @@
 import { bootEnvVariables } from "../config/bootConfig.js";
+import { originalConsoleMethods } from "../telemetry/telemetryRegistry.js";
 const LOG_LEVELS = ['DEBUG', 'INFO', 'WARN', 'ERROR', 'NONE'];
-const currentLogLevel = (bootEnvVariables.OASTLM_BOOT_LOG_LEVEL || 'INFO').toUpperCase();
-const serviceName = 'OAS-Telemetry';
-function log(level, ...messages) {
-    if (LOG_LEVELS.indexOf(level) >= LOG_LEVELS.indexOf(currentLogLevel)) {
-        const timestamp = new Date().toISOString();
-        console.log(`${timestamp} [${serviceName}] [${level}]:`, ...messages);
-    }
+const currentLogLevel = (bootEnvVariables.OASTLM_BOOT_LOG_LEVEL).toUpperCase();
+const serviceName = 'OAS-TLM-@-' + bootEnvVariables.OASTLM_BOOT_SERVICE_NAME;
+function shouldLog(level) {
+    return LOG_LEVELS.indexOf(level) >= LOG_LEVELS.indexOf(currentLogLevel);
 }
 export default {
-    debug: (...messages) => log('DEBUG', ...messages),
-    info: (...messages) => log('INFO', ...messages),
-    log: (...messages) => log('INFO', ...messages), // Alias for info
-    warn: (...messages) => log('WARN', ...messages),
-    error: (...messages) => log('ERROR', ...messages),
+    debug: (...messages) => {
+        if (shouldLog('DEBUG')) {
+            const timestamp = new Date().toISOString();
+            originalConsoleMethods.debug(`${timestamp} [${serviceName}] [DEBUG]:`, ...messages);
+        }
+    },
+    info: (...messages) => {
+        if (shouldLog('INFO')) {
+            const timestamp = new Date().toISOString();
+            originalConsoleMethods.info(`${timestamp} [${serviceName}] [INFO]:`, ...messages);
+        }
+    },
+    log: (...messages) => {
+        if (shouldLog('INFO')) {
+            const timestamp = new Date().toISOString();
+            originalConsoleMethods.log(`${timestamp} [${serviceName}] [INFO]:`, ...messages);
+        }
+    },
+    warn: (...messages) => {
+        if (shouldLog('WARN')) {
+            const timestamp = new Date().toISOString();
+            originalConsoleMethods.warn(`${timestamp} [${serviceName}] [WARN]:`, ...messages);
+        }
+    },
+    error: (...messages) => {
+        if (shouldLog('ERROR')) {
+            const timestamp = new Date().toISOString();
+            originalConsoleMethods.error(`${timestamp} [${serviceName}] [ERROR]:`, ...messages);
+        }
+    },
     currentLogLevel
 };

package/dist/types/config/bootConfig.d.ts

@@ -2,4 +2,5 @@ export declare const bootEnvVariables: {
     OASTLM_BOOT_ENV: string;
     OASTLM_BOOT_MODULE_DISABLED: boolean;
     OASTLM_BOOT_LOG_LEVEL: string;
+    OASTLM_BOOT_SERVICE_NAME: string;
 };

package/dist/types/config/config.d.ts

@@ -13,9 +13,10 @@ export declare const defaultConfig: {
     };
     auth: {
         enabled: boolean;
-        apiKeyMaxAge: number;
         password: string;
         jwtSecret: string;
+        accessTokenMaxAge: number;
+        refreshTokenMaxAge: number;
     };
     ai: {
         openAIKey: string | null;
@@ -70,9 +71,10 @@ export declare const getConfig: (userConfig?: UserConfig, fallbackConfig?: OasTl
     };
     auth: {
         enabled: boolean;
-        apiKeyMaxAge: number;
         password: string;
         jwtSecret: string;
+        accessTokenMaxAge: number;
+        refreshTokenMaxAge: number;
     };
     ai: {
         openAIKey: string | null;
@@ -126,9 +128,10 @@ export declare const getConfig: (userConfig?: UserConfig, fallbackConfig?: OasTl
     } | undefined;
     auth?: {
         enabled?: boolean | undefined;
-        apiKeyMaxAge?: number | undefined;
         password?: string | undefined;
         jwtSecret?: string | undefined;
+        accessTokenMaxAge?: number | undefined;
+        refreshTokenMaxAge?: number | undefined;
     } | undefined;
     ai?: {
         openAIKey?: string | null | undefined;

package/dist/types/telemetry/custom-implementations/exporters/InMemoryDbLogExporter.d.ts

@@ -17,7 +17,12 @@ export declare class InMemoryDbLogExporter extends Enabler implements LogRecordE
      * Shutdown the exporter.
      */
     shutdown(): Promise<void>;
-    find(query: any, messageSearch: string | null, callback: (err: any, docs: any) => void): void;
+    find(findConfig: {
+        query: any;
+        messageSearch: string | null;
+        limit: number;
+        sortOrder?: any;
+    }): Promise<any[]>;
     insert(data: any[], callback: (err: any, newDocs: any[]) => void): void;
     getFinishedLogs(): any[];
     /**
@@ -28,6 +33,7 @@ export declare class InMemoryDbLogExporter extends Enabler implements LogRecordE
      */
     private _formatLogRecord;
     set retentionTimeInSeconds(retentionTimeInSeconds: number);
+    get retentionTimeInSeconds(): number;
     private _insertLogs;
     private _startCleanupJob;
 }

package/dist/types/telemetry/custom-implementations/exporters/InMemoryDbMetricExporter.d.ts

@@ -17,5 +17,6 @@ export declare class InMemoryDbMetricExporter extends Enabler implements PushMet
      */
     insert(metrics: any[], callback: (err: any, newDocs: any[]) => void): void;
     set retentionTimeInSeconds(retentionTimeInSeconds: number);
+    get retentionTimeInSeconds(): number;
     private _startCleanupJob;
 }