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

package/dist/esm/tlm-ai/aiService.js

@@ -0,0 +1,94 @@
+import OpenAI from 'openai';
+import { agent } from './agent.js';
+class AIService {
+    constructor(config) {
+        this.config = config;
+        this.conversations = new Map();
+        this.openai = new OpenAI({
+            apiKey: this.config.apiKey,
+        });
+        this.model = config.model;
+        this.extraPrompts = config.extraPrompts || [];
+    }
+    createConversation() {
+        const id = Math.random().toString(36).substring(2, 15);
+        const conversation = { id, messages: [] };
+        this.conversations.set(id, conversation);
+        return conversation;
+    }
+    listConversations() {
+        return Array.from(this.conversations.values());
+    }
+    getConversation(id) {
+        return this.conversations.get(id);
+    }
+    deleteConversation(id) {
+        return this.conversations.delete(id);
+    }
+    async sendMessage(conversationId, content, model) {
+        const conversation = this.conversations.get(conversationId);
+        if (!conversation)
+            throw new Error('Conversation not found');
+        conversation.messages.push({
+            role: 'system',
+            timestamp: new Date().toISOString(),
+            content: "This is a telemetry chat. Focus your replies strictly on the topics and instructions defined by the system prompts and the available tools. Do not answer outside of these boundaries. Reply in the same language as the question."
+        });
+        if (this.extraPrompts.length > 0) {
+            this.extraPrompts.forEach(prompt => {
+                conversation.messages.push({ role: 'system', content: prompt, timestamp: new Date().toISOString() });
+            });
+        }
+        conversation.messages.push({ role: 'user', content, timestamp: new Date().toISOString() });
+        // Set conversation name if not set
+        if (!('name' in conversation) || !conversation.name) {
+            conversation.name = content.slice(0, 30);
+        }
+        // Use the agent function with tools
+        // Internaly pushes new messages to conversation.messages
+        const currentMessagesCount = conversation.messages.length;
+        await agent(this.openai, conversation.messages, model || this.model, this.extraPrompts);
+        // Return the last assistant message (the one just added by agent)
+        const generatedMessages = conversation.messages.slice(currentMessagesCount);
+        return generatedMessages;
+    }
+    listConversationsMinimal() {
+        return Array.from(this.conversations.values()).map(c => ({
+            id: c.id,
+            name: c.name,
+        }));
+    }
+    async listModels() {
+        const { data } = await this.openai.models.list();
+        return data
+            .map(m => m.id)
+            .sort();
+    }
+    async isValidModel(modelId) {
+        try {
+            await this.openai.models.retrieve(modelId);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+let aiService;
+export function configureAiService(config) {
+    const openAIKey = config.ai?.openAIKey;
+    const model = config.ai.openAIModel;
+    const extraPrompts = config.ai.extraContextPrompts;
+    if (!openAIKey)
+        throw new Error('OpenAI API key is required');
+    aiService = new AIService({
+        apiKey: openAIKey,
+        model,
+        extraPrompts
+    });
+}
+export function getAiService() {
+    if (!aiService)
+        throw new Error('AI Service not configured');
+    return aiService;
+}

package/dist/esm/tlm-ai/tools.js

@@ -1,6 +1,4 @@
-import axios from 'axios';
 import logger from '../utils/logger.js';
-import { getKnownMicroservices } from './knownMicroservices.js';
 import { inMemoryDbLogExporter, inMemoryDbMetricExporter, inMemoryDbSpanExporter } from '../telemetry/telemetryRegistry.js';
 const getTraces = async (searchInput) => {
     logger.debug("getTraces called with searchInput:", searchInput);
@@ -27,32 +25,22 @@ const getTraces = async (searchInput) => {
 const getLogs = async (startDate, endDate) => {
     logger.debug("getLogs called with startDate:", startDate, "endDate:", endDate);
     try {
-        let nedbQuery = {};
-        if (!startDate && !endDate) {
-            logger.debug("No date range provided, fetching all logs.");
-        }
-        else {
-            logger.debug(`Fetching logs from ${startDate} to ${endDate}`);
-            nedbQuery = {
-                timestamp: {
-                    $gte: startDate ? new Date(startDate).getTime() : 0, // Epoch ms
-                    $lte: endDate ? new Date(endDate).getTime() : Date.now() // Epoch ms
-                }
-            };
-        }
-        const logs = [];
-        await new Promise((resolve, reject) => {
-            inMemoryDbLogExporter.find(nedbQuery, null, (err, docs) => {
-                if (err) {
-                    reject(err);
-                }
-                else {
-                    logs.push(...docs);
-                    logger.debug(`Found ${logs.length} logs in the specified range.`);
-                    resolve();
-                }
-            });
-        });
+        // Timestamps are stored in microseconds in the DB (must multiply by 1000)
+        const startEpoch = startDate ? new Date(startDate).getTime() * 1000 : 0;
+        const endEpoch = endDate ? new Date(endDate).getTime() * 1000 : Date.now() * 1000;
+        logger.debug(`Fetching logs from ${startEpoch} to ${endEpoch}`);
+        const nedbQuery = {
+            timestamp: {
+                $gte: startEpoch,
+                $lte: endEpoch
+            }
+        };
+        const logs = (await inMemoryDbLogExporter.find({
+            query: nedbQuery,
+            messageSearch: null,
+            limit: 50 // or any appropriate limit
+        })) || [];
+        logger.debug(`Found ${logs.length} logs in the specified range.`);
         const simplifiedLogs = getSimplifiedLogs(logs);
         return { logs: simplifiedLogs };
     }
@@ -61,33 +49,6 @@ const getLogs = async (startDate, endDate) => {
         throw error;
     }
 };
-const getMetrics = async (searchInput) => {
-    logger.debug("getMetrics called with searchInput:", searchInput);
-    try {
-        const search = searchInput || {};
-        const metrics = await new Promise((resolve, reject) => {
-            inMemoryDbMetricExporter.find(search, (err, docs) => {
-                if (err)
-                    reject(err);
-                else
-                    resolve(docs || []);
-            });
-        });
-        const simplifiedMetrics = getSimplifiedMetrics(metrics);
-        logger.debug(`Searching for metrics with searchInput: ${JSON.stringify(search)}`);
-        logger.debug(`Metrics found: ${JSON.stringify(simplifiedMetrics.length)}`);
-        return { metrics: simplifiedMetrics };
-    }
-    catch (error) {
-        logger.error('Error fetching metrics:', error);
-        throw error;
-    }
-};
-const getCurrentTimestampInEpoch = () => {
-    logger.debug("Getting the current timestamp in epoch format...");
-    const now = new Date();
-    return { currentTimestampInEpoch: now.getTime(), currentTimestampInEpochSeconds: Math.floor(now.getTime() / 1000) };
-};
 const startTelemetry = () => {
     logger.debug("Starting telemetry...");
     inMemoryDbSpanExporter.enable();
@@ -114,28 +75,10 @@ const getTelemetryStatus = () => {
         metricsEnabled: inMemoryDbMetricExporter.isEnabled()
     };
 };
-const talkToExternalMicroserviceAgent = async (message, microserviceId) => {
-    logger.debug("talkToExternalMicroserviceAgent called with question:", message, "microservice:", microserviceId);
-    const knownMicroservices = getKnownMicroservices();
-    const identifiedMicroservice = knownMicroservices.find(m => m.id === microserviceId);
-    if (!identifiedMicroservice) {
-        logger.error(`Agent tried to call an unknown microservice: ${microserviceId}, available microservices: ${knownMicroservices.map(m => m.id).join(', ')}`);
-        return {
-            microservice: microserviceId,
-            response: `I cannot help with that. The microservice ${microserviceId} is not recognized. Available microservices are: ${knownMicroservices.map(m => m.id).join(', ')}`
-        };
-    }
-    const microserviceResponse = await axios.post(identifiedMicroservice.url, {
-        question: message
-    });
-    return {
-        microservice: microserviceId,
-        response: microserviceResponse.data
-    };
-};
-const getMicroserviceAgents = () => {
-    logger.debug("Getting microservice agents...");
-    return getKnownMicroservices();
+const getCurrentDate = () => {
+    logger.debug("Getting the current date in ISO format...");
+    const now = new Date();
+    return { currentDateISO: now.toISOString() };
 };
 const tools = [
     {
@@ -227,7 +170,8 @@ const tools = [
             description: `Fetches log data for the microservice. 
         Logs provide information about system events, including timestamps, log levels (e.g., info, error), and messages. 
         The 'startDate' and 'endDate' parameters define the time range for fetching logs. 
-        If don't provide a range, all logs will be fetched. Providing a specific range improves performance.
+        If you need a date, you MUST first call the "getCurrentDate" tool to obtain the current date in ISO format, and then use it as a parameter.
+        If you don't provide a range, all logs will be fetched. Providing a specific range improves performance.
         Example 'startDate' and 'endDate':
         {
           "startDate": "2023-10-01T00:00:00Z",
@@ -247,41 +191,6 @@ const tools = [
             }
         }
     },
-    {
-        type: "function",
-        function: {
-            name: "getMetrics",
-            description: `Fetches metrics data for the microservice. 
-        Metrics provide performance-related data, such as CPU usage, memory usage, and process-specific metrics. 
-        The 'searchInput' parameter is an object used to filter metrics based on specific criteria. 
-        This is a NeDB query using MongoDB-like (NeDB) syntax. If 'searchInput' is null, all metrics will be fetched. Providing specific filters improves performance.
-        
-        Example 'searchInput':
-        {
-          "timestamp": { "$gte": 1747651105757, "$lte": 1747651200935 }
-        }
-        
-        Common filters include timestamps.`,
-            parameters: {
-                type: "object",
-                properties: {
-                    searchInput: {
-                        type: "object",
-                        description: `Optional search criteria for filtering metrics. 
-              This is a NeDB query using MongoDB-like (NeDB) syntax. 
-              For example, you can filter by timestamps. 
-              If null, all metrics will be returned.`,
-                        properties: {
-                            "timestamp": { type: "object", properties: { "$gte": { type: "integer" }, "$lte": { type: "integer" } } },
-                            "cpuUsageData.cpuNumber": { type: "string" },
-                            "memoryData.used": { type: "integer" }
-                        }
-                    }
-                },
-                required: ["searchInput"]
-            }
-        }
-    },
     {
         type: "function",
         function: {
@@ -321,50 +230,9 @@ const tools = [
     {
         type: "function",
         function: {
-            name: "getCurrentTimestampInEpoch",
-            description: `Retrieves the current timestamp in epoch format (miliseconds or seconds). 
-        This function calculates the timestamp for the current moment in milliseconds since the Unix epoch.in .currentTimestampInEpoch. Also returns the current timestamp in seconds in .currentTimestampInEpochSeconds.`,
-            parameters: {}
-        }
-    },
-    {
-        type: "function",
-        function: {
-            name: "talkToExternalMicroserviceAgent",
-            description: `Use this function to communicate with external microservice agent.
-        if you want to talk to a microservice agent, you must provide the message and the microservice you want to talk to.  
-        When you call this function, it will send the message to the specified microservice and return the response.
-
-        Example 'message':
-        {
-          "message": "What is the status of the service?",
-          "microservice": "Reporter"
-        }
-
-        Microservices Availables (by ID):
-        ${getKnownMicroservices().map(m => m.id).join(", ")}
-        `,
-            parameters: {
-                type: "object",
-                properties: {
-                    message: {
-                        type: "string",
-                        description: `The message to be sent to the external microservice agent.`
-                    },
-                    microservice: {
-                        type: "string"
-                    }
-                },
-                required: ["message", "microservice"]
-            }
-        }
-    },
-    {
-        type: "function",
-        function: {
-            name: "getMicroserviceAgents",
-            description: `Retrieves the list of available microservice agents. 
-        This function provides information about the microservices that can be communicated with.`,
+            name: "getCurrentDate",
+            description: `Returns the current date in ISO 8601 format (e.g., "2024-06-07T12:34:56.789Z"). 
+        Use this tool to obtain the current date when you need to specify a date for other tools, such as "getLogs".`,
             parameters: {}
         }
     }
@@ -372,107 +240,13 @@ const tools = [
 const availableTools = {
     getTraces,
     getLogs,
-    getMetrics,
     startTelemetry,
     stopTelemetry,
     resetTelemetry,
     getTelemetryStatus,
-    getCurrentTimestampInEpoch,
-    talkToExternalMicroserviceAgent,
-    getMicroserviceAgents
+    getCurrentDate
 };
 export { tools, availableTools, };
-function getSimplifiedMetrics(metrics) {
-    return metrics.map(resourceMetric => {
-        const serviceName = resourceMetric.resource?._memoizedAttributes?.service?.name || 'unknown-service';
-        const cpuUtilization = {};
-        let cpuCount = 0;
-        const memoryUsageMB = { used: 0, free: 0 };
-        const memoryUtilizationPercent = { used: 0, free: 0 };
-        const networkIO = { transmit: 0, receive: 0 };
-        const processCPU = {};
-        let processMemoryUsage = 0;
-        for (const scopeMetric of resourceMetric.scopeMetrics) {
-            for (const metric of scopeMetric.metrics) {
-                const name = metric.descriptor.name;
-                if (name === 'system.cpu.utilization') {
-                    const stateSums = {};
-                    const stateCounts = {};
-                    for (const dp of metric.dataPoints) {
-                        const state = dp.attributes?.system?.cpu?.state;
-                        if (!state)
-                            continue;
-                        // @ts-expect-error index signature
-                        stateSums[state] = (stateSums[state] || 0) + dp.value;
-                        // @ts-expect-error index signature
-                        stateCounts[state] = (stateCounts[state] || 0) + 1;
-                    }
-                    for (const state in stateSums) {
-                        // @ts-expect-error index signature
-                        cpuUtilization[state] = stateSums[state] / stateCounts[state];
-                    }
-                    cpuCount = Math.max(...metric.dataPoints.map((dp) => parseInt(dp.attributes?.system?.cpu?.logical_number || 0, 10))) + 1;
-                }
-                if (name === 'system.memory.usage') {
-                    for (const dp of metric.dataPoints) {
-                        const state = dp.attributes?.system?.memory?.state;
-                        //  @ts-expect-error index signature
-                        if (state)
-                            memoryUsageMB[state] = dp.value;
-                    }
-                }
-                if (name === 'system.memory.utilization') {
-                    for (const dp of metric.dataPoints) {
-                        const state = dp.attributes?.system?.memory?.state;
-                        //  @ts-expect-error index signature
-                        if (state)
-                            memoryUtilizationPercent[state] = dp.value;
-                    }
-                }
-                if (name === 'system.network.io') {
-                    for (const dp of metric.dataPoints) {
-                        const direction = dp.attributes?.network?.io?.direction;
-                        //  @ts-expect-error index signature
-                        if (direction)
-                            networkIO[direction] += dp.value;
-                    }
-                }
-                if (name === 'process.cpu.time') {
-                    for (const dp of metric.dataPoints) {
-                        const state = dp.attributes?.process?.cpu?.state;
-                        //  @ts-expect-error index signature
-                        if (state)
-                            processCPU[state] = dp.value;
-                    }
-                }
-                if (name === 'process.memory.usage') {
-                    processMemoryUsage = metric.dataPoints[0]?.value || 0;
-                }
-            }
-        }
-        return {
-            service: serviceName,
-            cpu: {
-                avgUtilization: cpuUtilization,
-                cores: cpuCount,
-            },
-            memory: {
-                usedGB: (memoryUsageMB.used || 0) / (1024 ** 3),
-                freeGB: (memoryUsageMB.free || 0) / (1024 ** 3),
-                usedPercent: (memoryUtilizationPercent.used || 0) * 100,
-                freePercent: (1 - (memoryUtilizationPercent.used || 0)) * 100,
-            },
-            network: {
-                transmittedMB: networkIO.transmit / (1024 ** 2),
-                receivedMB: networkIO.receive / (1024 ** 2),
-            },
-            process: {
-                cpuTimeSec: processCPU,
-                memoryUsageMB: processMemoryUsage / (1024 ** 2),
-            }
-        };
-    });
-}
 function getSimplifiedTraces(spans) {
     return spans.map((span) => {
         return {
@@ -490,10 +264,10 @@ function getSimplifiedTraces(spans) {
 function getSimplifiedLogs(logs) {
     return logs.map((log) => ({
         service: log.resource?.attributes?.service?.name || undefined,
-        timestamp: log.timestamp,
+        timestamp: new Date(log.timestamp / 1000).toISOString(), // converting microseconds to milliseconds
+        severityText: log.severityText,
         message: log.body,
         traceId: log.traceId,
-        spanId: log.spanId,
-        source: log.attributes?.source?.source || undefined,
+        source: log.attributes?.source || undefined,
     }));
 }

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

@@ -16,19 +16,19 @@ export const getLogin = (oasTlmConfig) => (req, res) => {
         if (password === oasTlmConfig.auth.password) {
             const accessToken = generateAccessToken(oasTlmConfig.auth.jwtSecret, oasTlmConfig.auth.accessTokenMaxAge);
             const refreshToken = generateRefreshToken(oasTlmConfig.auth.jwtSecret, oasTlmConfig.auth.refreshTokenMaxAge);
-            res.cookie("accessToken", accessToken, {
+            res.cookie("oas-tlm-access-token", accessToken, {
                 maxAge: oasTlmConfig.auth.accessTokenMaxAge,
                 httpOnly: true,
                 secure: process.env.NODE_ENV === "production",
                 sameSite: "lax",
                 path: "/"
             });
-            res.cookie("refreshToken", refreshToken, {
+            res.cookie("oas-tlm-refresh-token", refreshToken, {
                 maxAge: oasTlmConfig.auth.refreshTokenMaxAge,
                 httpOnly: true,
                 secure: process.env.NODE_ENV === "production",
                 sameSite: "lax",
-                path: oasTlmConfig.general.baseUrl + "/auth/refresh" // <-- cambiado de "/auth/refresh" a oasTlmConfig.general.baseUrl + "/auth/refresh"
+                path: oasTlmConfig.general.baseUrl + "/auth/refresh"
             });
             res.status(200).json({ valid: true, message: "Login successful" });
             return;
@@ -45,8 +45,8 @@ export const getLogout = (oasTlmConfig) => (req, res) => {
         res.status(200).json({ valid: true, message: "Auth disabled" });
         return;
     }
-    res.clearCookie('accessToken', { path: '/' });
-    res.clearCookie('refreshToken', { path: oasTlmConfig.general.baseUrl + '/auth/refresh' }); // <-- cambiado de "/auth/refresh" a oasTlmConfig.general.baseUrl + "/auth/refresh"
+    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 getRefresh = (oasTlmConfig) => (req, res) => {
@@ -54,7 +54,7 @@ export const getRefresh = (oasTlmConfig) => (req, res) => {
         res.status(200).json({ valid: true, message: "Auth disabled" });
         return;
     }
-    const refreshToken = req.cookies.refreshToken;
+    const refreshToken = req.cookies["oas-tlm-refresh-token"];
     if (!refreshToken) {
         res.status(401).json({ valid: false, message: "No refresh token" });
         return;
@@ -64,7 +64,7 @@ export const getRefresh = (oasTlmConfig) => (req, res) => {
         if (payload.type !== "refresh")
             throw new Error("Invalid token type");
         const accessToken = generateAccessToken(oasTlmConfig.auth.jwtSecret, oasTlmConfig.auth.accessTokenMaxAge);
-        res.cookie("accessToken", accessToken, {
+        res.cookie("oas-tlm-access-token", accessToken, {
             maxAge: oasTlmConfig.auth.accessTokenMaxAge,
             httpOnly: true,
             secure: process.env.NODE_ENV === "production",
@@ -73,7 +73,7 @@ export const getRefresh = (oasTlmConfig) => (req, res) => {
         });
         res.status(200).json({ valid: true, message: "Refreshed" });
     }
-    catch (err) {
+    catch {
         res.status(401).json({ valid: false, message: "Invalid refresh token" });
     }
 };

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

@@ -4,7 +4,7 @@ export function getAuthMiddleware(oasTlmConfig) {
         if (!oasTlmConfig.auth.enabled) {
             return next();
         }
-        const token = req.cookies.accessToken;
+        const token = req.cookies["oas-tlm-access-token"];
         if (!token) {
             res.status(401).json({ valid: false, message: "No access token" });
             return;

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);