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

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

@@ -1,46 +1,63 @@
-import { getAgent } from './agent.js';
-import { setKnownMicroservices, getKnownMicroservices } from './knownMicroservices.js';
-import logger from '../utils/logger.js';
-export const answerQuestion = (oasTlmConfig) => async (req, res) => {
+import { getAiService } from './aiService.js';
+export async function createConversation(req, res) {
     try {
-        const { question } = req.body;
-        if (!question)
-            res.status(400).json({ error: 'Missing question' });
-        const getAgentResponse = getAgent(oasTlmConfig);
-        const answer = await getAgentResponse(question);
-        res.json({ answer });
-    }
-    catch (error) {
-        logger.error(error);
-        res.status(500).json({ error: 'Internal error' });
-    }
-};
-export const setKnownMicroservicesHandler = () => (req, res) => {
+        const conversation = getAiService().createConversation();
+        res.status(201).json(conversation);
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+}
+export async function listConversations(req, res) {
+    try {
+        // Only return id and name for each conversation
+        const conversations = getAiService().listConversationsMinimal();
+        res.json(conversations);
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+}
+export async function getConversationHistory(req, res) {
+    try {
+        const { conversationId } = req.params;
+        const conversation = getAiService().getConversation(conversationId);
+        if (!conversation) {
+            res.status(404).json({ error: 'Not found' });
+            return;
+        }
+        res.json(conversation);
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+}
+export async function deleteConversation(req, res) {
     try {
-        const { microservices } = req.body;
-        if (!Array.isArray(microservices)) {
-            res.status(400).json({ error: 'Invalid microservices format. Expected an array.' });
+        const { conversationId } = req.params;
+        const deleted = getAiService().deleteConversation(conversationId);
+        if (!deleted) {
+            res.status(404).json({ error: 'Not found' });
             return;
         }
-        setKnownMicroservices(microservices);
-        res.json({
-            message: "Microservices configuration updated successfully.",
-            knownMicroservices: getKnownMicroservices(),
-            note: "In the future, OAS-Telemetry will support autodiscovery, making this configuration unnecessary.",
-        });
-    }
-    catch (error) {
-        logger.error(error);
-        res.status(500).json({ error: 'Internal error' });
-    }
-};
-export const getKnownMicroservicesHandler = () => (req, res) => {
+        res.status(204).send();
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+}
+export async function sendMessage(req, res) {
     try {
-        const microservices = getKnownMicroservices();
-        res.json({ knownMicroservices: microservices });
+        const { conversationId } = req.params;
+        const { content } = req.body;
+        if (!content) {
+            res.status(400).json({ error: 'Missing content' });
+            return;
+        }
+        const messages = await getAiService().sendMessage(conversationId, content);
+        res.json(messages);
     }
-    catch (error) {
-        logger.error(error);
-        res.status(500).json({ error: 'Internal error' });
+    catch (err) {
+        res.status(500).json({ error: err.message });
     }
-};
+}

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

@@ -1,9 +1,16 @@
 import { Router } from 'express';
-import { answerQuestion, setKnownMicroservicesHandler, getKnownMicroservicesHandler } from './aiController.js';
+import { createConversation, deleteConversation, getConversationHistory, listConversations, sendMessage } from './aiController.js';
+import { configureAiService } from './aiService.js';
 export const getAIRoutes = (oasTlmConfig) => {
     const router = Router();
-    router.post('/chat', answerQuestion(oasTlmConfig));
-    router.post('/microservices', setKnownMicroservicesHandler());
-    router.get('/microservices', getKnownMicroservicesHandler());
+    configureAiService(oasTlmConfig); //oasTlmConfig.ai.openAIKey
+    router.get('/chat/health', (req, res) => {
+        res.status(200).send('AI service is healthy');
+    });
+    router.get('/chat', listConversations);
+    router.post('/chat', createConversation);
+    router.get('/chat/:conversationId', getConversationHistory);
+    router.post('/chat/:conversationId/message', sendMessage);
+    router.delete('/chat/:conversationId', deleteConversation);
     return router;
 };

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