@oas-tools/oas-telemetry 0.6.2 → 0.7.0-alpha.0

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

@@ -0,0 +1,490 @@
+import axios from 'axios';
+import { globalOasTlmConfig } from '../config.js';
+import logger from '../utils/logger.js';
+import { getKnownMicroservices } from './knownMicroservices.js';
+const getTraces = async (searchInput) => {
+    logger.debug("getTraces called with searchInput:", searchInput);
+    try {
+        const search = searchInput || {};
+        const traces = await new Promise((resolve, reject) => {
+            globalOasTlmConfig.dynamicSpanExporter.exporter.find(search, (err, docs) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve(docs);
+            });
+        });
+        const simplifiedTraces = getSimplifiedTraces(traces);
+        logger.debug(`Searching for traces with searchInput: ${JSON.stringify(search)}`);
+        logger.debug(`Traces found: ${JSON.stringify(simplifiedTraces.length)}`);
+        return { traces: simplifiedTraces };
+    }
+    catch (error) {
+        logger.error('Error fetching traces:', error);
+        throw error;
+    }
+};
+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) => {
+            globalOasTlmConfig.debugExporter.find(nedbQuery, null, (err, docs) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    logs.push(...docs);
+                    logger.debug(`Found ${logs.length} logs in the specified range.`);
+                    resolve();
+                }
+            });
+        });
+        const simplifiedLogs = getSimplifiedLogs(logs);
+        return { logs: simplifiedLogs };
+    }
+    catch (error) {
+        logger.error('Error fetching logs:', error);
+        throw error;
+    }
+};
+const getMetrics = async (searchInput) => {
+    logger.debug("getMetrics called with searchInput:", searchInput);
+    try {
+        const search = searchInput || {};
+        const metrics = await new Promise((resolve, reject) => {
+            globalOasTlmConfig.metricsExporter.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...");
+    globalOasTlmConfig.dynamicSpanExporter.exporter.start();
+};
+const stopTelemetry = () => {
+    logger.debug("Stopping telemetry...");
+    globalOasTlmConfig.dynamicSpanExporter.exporter.stop();
+};
+const resetTelemetry = () => {
+    logger.debug("Resetting telemetry...");
+    globalOasTlmConfig.dynamicSpanExporter.exporter.reset();
+};
+const getTelemetryStatus = () => {
+    logger.debug("Getting telemetry status...");
+    const isRunning = globalOasTlmConfig.dynamicSpanExporter.exporter.isRunning() || false;
+    return { active: isRunning };
+};
+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 tools = [
+    {
+        type: "function",
+        function: {
+            name: "getTraces",
+            description: `Fetches trace data for the microservice. 
+        Traces provide detailed information about requests and their lifecycle, including HTTP attributes (e.g., URL, method, status code), 
+        network details (e.g., peer IP, port), and timing information. 
+        The 'searchInput' parameter is an object used to filter traces based on specific criteria. 
+        This is a NeDB query using MongoDB-like syntax (neDB). If 'searchInput' is null, all traces will be fetched.
+        Providing specific filters improves performance.
+
+        Available properties for filtering:
+        {
+          "name": "GET", // Name of the span
+          "kind": 1, // 1 for incoming requests, 2 for outgoing requests
+          "attributes": {
+            "http": {
+              "url": "http://localhost:3002/api/v1/greet",
+              "host": "localhost:3002",
+              "method": "GET",
+              "scheme": "http",
+              "target": "/api/v1/greet",
+              "user_agent": "PostmanRuntime/7.44.0",
+              "request_content_length_uncompressed": 39,
+              "flavor": "1.1",
+              "status_code": 200,
+              "status_text": "OK"
+            },
+            "net": {
+              "host": {
+                "name": "localhost",
+                "ip": "::1",
+                "port": 3002
+              },
+              "transport": "ip_tcp",
+              "peer": {
+                "ip": "::1",
+                "port": 50361
+              }
+            }
+          },
+          "traceId": "5f7df252eb00e873bbd6441f86b71dac",
+          "spanId": "fbd8ea558dd6ac32",
+          "service": "oas-telemetry-service",
+          "startTime": { "0": 1747666254, "1": 333000000 },
+          "endTime": { "0": 1747666254, "1": 335071700 },
+          "_duration": { "0": 0, "1": 2071700 }
+        }
+
+
+        you can use $or, or $gte or operators like that if needed never > or similar.
+        Take into account that startTime.0 and endTime.0 are in epoch SECONDS format not milliseconds.
+        For time search ALWAYS use "endTime.0": { "$gte": number } or similar with other operators and startTime.0.
+        Common filters include HTTP attributes (e.g., method, status code, URL), timestamps (e.g., 'endTime.0'), or duration ('_duration').
+        
+        Example 'query':
+        {
+          "attributes.http.method": "GET",
+          "attributes.http.status_code": 200, //when asked for ANY error you can use $gte : 400 operator
+          "attributes.http.url": "http://localhost:3002/api/v1/greet",
+          "_duration": { "$lte": 5000000 },
+          "endTime.0": { "$gte": 1747666254 },
+        }
+        you must give a {searchInput: query} object to the function
+        
+        `,
+            parameters: {
+                type: "object",
+                properties: {
+                    searchInput: {
+                        type: "object",
+                        description: `Optional search criteria for filtering traces. 
+              This is a NeDB query using MongoDB-like (neDB) syntax. 
+              For example, you can filter by HTTP attributes, timestamps, or duration. 
+              If null, all traces will be returned.`,
+                        additionalProperties: true
+                    }
+                },
+                required: ["searchInput"]
+            }
+        }
+    },
+    {
+        type: "function",
+        function: {
+            name: "getLogs",
+            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.
+        Example 'startDate' and 'endDate':
+        {
+          "startDate": "2023-10-01T00:00:00Z",
+          "endDate": "2023-10-02T00:00:00Z"
+        }
+        Common filters include timestamps or log levels.`,
+            parameters: {
+                type: "object",
+                properties: {
+                    startDate: {
+                        type: "string"
+                    },
+                    endDate: {
+                        type: "string"
+                    }
+                },
+            }
+        }
+    },
+    {
+        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: {
+            name: "startTelemetry",
+            description: `Starts the telemetry data collection process. 
+        This function initializes the telemetry system and begins capturing trace, log, and metric data.`,
+            parameters: {}
+        }
+    },
+    {
+        type: "function",
+        function: {
+            name: "stopTelemetry",
+            description: `Stops the telemetry data collection process. 
+        This function halts the telemetry system and stops capturing trace, log, and metric data.`,
+            parameters: {}
+        }
+    },
+    {
+        type: "function",
+        function: {
+            name: "resetTelemetry",
+            description: `Resets the telemetry data collection process. 
+        This function clears any existing telemetry data and prepares the system for a fresh start.`,
+            parameters: {}
+        }
+    },
+    {
+        type: "function",
+        function: {
+            name: "getTelemetryStatus",
+            description: `Retrieves the current status of the telemetry system. 
+        This function checks whether the telemetry system is currently active or inactive.`,
+            parameters: {}
+        }
+    },
+    {
+        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.`,
+            parameters: {}
+        }
+    }
+];
+const availableTools = {
+    getTraces,
+    getLogs,
+    getMetrics,
+    startTelemetry,
+    stopTelemetry,
+    resetTelemetry,
+    getTelemetryStatus,
+    getCurrentTimestampInEpoch,
+    talkToExternalMicroserviceAgent,
+    getMicroserviceAgents
+};
+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?.debugical_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 {
+            name: span.name,
+            kind: span.kind,
+            attributes: span.attributes,
+            resource: span.resource,
+            _spanContext: span._spanContext,
+            startTime: span.startTime,
+            endTime: span.endTime,
+            _duration: span._duration
+        };
+    });
+}
+function getSimplifiedLogs(logs) {
+    return logs.map((log) => ({
+        service: log.resource?.attributes?.service?.name || undefined,
+        timestamp: log.timestamp,
+        message: log.body,
+        traceId: log.traceId,
+        spanId: log.spanId,
+        source: log.attributes?.source?.source || undefined,
+    }));
+}

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

@@ -0,0 +1,41 @@
+import { globalOasTlmConfig } from '../config.js';
+import jwt from 'jsonwebtoken';
+import logger from '../utils/logger.js';
+export const login = (req, res) => {
+    try {
+        const { password } = req.body;
+        if (password === globalOasTlmConfig.password) {
+            const options = {
+                maxAge: globalOasTlmConfig.apiKeyMaxAge,
+                httpOnly: true,
+                secure: true,
+                signed: false
+            };
+            const apiKey = jwt.sign({ password: globalOasTlmConfig.password }, globalOasTlmConfig.jwtSecret);
+            res.cookie('apiKey', apiKey, options);
+            res.status(200).json({ valid: true, message: 'API Key is valid' });
+            return;
+        }
+        res.status(400).json({ valid: false, message: 'Invalid API Key' });
+    }
+    catch (error) {
+        logger.log("Error: ", error);
+        res.status(500).json({ valid: false, message: 'Internal server error' });
+    }
+};
+export const logout = (req, res) => {
+    res.clearCookie('apiKey');
+    res.redirect(globalOasTlmConfig.baseURL + '/login');
+};
+export const check = (req, res) => {
+    if (!req.cookies.apiKey) {
+        res.status(200).json({ valid: false, message: 'API Key is invalid' });
+        return;
+    }
+    const decoded = jwt.verify(req.cookies.apiKey, globalOasTlmConfig.jwtSecret);
+    if (decoded.password === globalOasTlmConfig.password) {
+        res.status(200).json({ valid: true, message: 'API Key is valid' });
+        return;
+    }
+    res.status(200).json({ valid: false, message: 'Invalid API Key' });
+};

package/{src/middleware → dist/esm/tlm-auth}/authMiddleware.js

@@ -1,14 +1,12 @@
-import { globalOasTlmConfig } from "../config.js";
-import jwt from 'jsonwebtoken';
-
-export function authMiddleware(req, res, next) {
-    const apiKey = req.cookies.apiKey;
-    if (apiKey) {
-        const decoded = jwt.verify(apiKey, globalOasTlmConfig.jwtSecret);
-        if (decoded.password === globalOasTlmConfig.password) {
-            return next();
-        }
-    }
-    res.status(401).redirect(globalOasTlmConfig.baseURL + '/login');
-
-}
+import { globalOasTlmConfig } from "../config.js";
+import jwt from 'jsonwebtoken';
+export function authMiddleware(req, res, next) {
+    const apiKey = req.cookies.apiKey;
+    if (apiKey) {
+        const decoded = jwt.verify(apiKey, globalOasTlmConfig.jwtSecret);
+        if (decoded.password === globalOasTlmConfig.password) {
+            return next();
+        }
+    }
+    res.status(401).redirect(globalOasTlmConfig.baseURL + '/login');
+}

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

@@ -0,0 +1,7 @@
+import { Router } from 'express';
+import { login, logout, check } from './authController.js';
+const router = Router();
+router.post('/login', login);
+router.get('/logout', logout);
+router.get('/check', check);
+export default router;

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

@@ -0,0 +1,36 @@
+import { globalOasTlmConfig } from '../config.js';
+export const listLogs = async (req, res) => {
+    try {
+        const logs = globalOasTlmConfig.logExporter.getFinishedSpans();
+        res.send({ logsCount: logs.length, logs: logs });
+    }
+    catch (err) {
+        console.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?.search || null; // Search term for MiniSearch
+    const findQuery = body?.find || {}; // Query for NeDB
+    console.dir(`findLogs called with query: ${JSON.stringify(findQuery)} and search ${messageSearch}`, { depth: 3 });
+    try {
+        const results = await new Promise((resolve, reject) => {
+            globalOasTlmConfig.logExporter.find(findQuery, messageSearch, (err, docs) => {
+                if (err)
+                    return reject(err);
+                resolve(docs);
+            });
+        });
+        const typedResults = results;
+        res.send({ logsCount: typedResults.length, logs: typedResults });
+    }
+    catch (err) {
+        console.error(err);
+        res.status(500).send({ error: 'Failed to find logs', details: err.message });
+    }
+};
+export const resetLogs = (req, res) => {
+    globalOasTlmConfig.logExporter.reset();
+    res.send('Logs reset');
+};

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

@@ -0,0 +1,7 @@
+import { Router } from 'express';
+import { listLogs, findLogs, resetLogs } from './logController.js';
+export const logRoutes = Router();
+logRoutes.get('/', listLogs);
+logRoutes.post('/find', findLogs);
+logRoutes.get('/reset', resetLogs);
+export default logRoutes;

package/{src/controllers → dist/esm/tlm-metric}/metricsController.js

@@ -1,30 +1,28 @@
-import { globalOasTlmConfig } from '../config.js';
-
-export const listMetrics = async (req, res) => {
-    try {
-        const metrics = await globalOasTlmConfig.metricsExporter.getFinishedMetrics();
-        res.send({ metricsCount: metrics.length, metrics: metrics });
-    } catch (err) {
-        console.error(err);
-        res.status(500).send({ error: 'Failed to list metrics data' });
-    }
-}
-
-export const findMetrics = (req, res) => {
-    const body = req.body;
-    const search = body?.search ? body.search : {};
-    globalOasTlmConfig.metricsExporter.find(search, (err, docs) => {
-        if (err) {
-            console.error(err);
-            res.status(404).send({ metricsCount: 0, metrics: [], error: err });
-            return;
-        }
-        const metrics = docs;
-        res.send({ metricsCount: metrics.length, metrics: metrics });
-    });
-}
-
-export const resetMetrics = (req, res) => {
-    globalOasTlmConfig.metricsExporter.reset();
-    res.send('Metrics reset');
-}
+import { globalOasTlmConfig } from '../config.js';
+export const listMetrics = async (req, res) => {
+    try {
+        const metrics = await globalOasTlmConfig.metricsExporter.getFinishedMetrics();
+        res.send({ metricsCount: metrics.length, metrics: metrics });
+    }
+    catch (err) {
+        console.error(err);
+        res.status(500).send({ error: 'Failed to list metrics data' });
+    }
+};
+export const findMetrics = (req, res) => {
+    const body = req.body;
+    const search = body?.search ? body.search : {};
+    globalOasTlmConfig.metricsExporter.find(search, (err, docs) => {
+        if (err) {
+            console.error(err);
+            res.status(404).send({ metricsCount: 0, metrics: [], error: err });
+            return;
+        }
+        const metrics = docs;
+        res.send({ metricsCount: metrics.length, metrics: metrics });
+    });
+};
+export const resetMetrics = (req, res) => {
+    globalOasTlmConfig.metricsExporter.reset();
+    res.send('Metrics reset');
+};