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

package/dist/cjs/tlm-ai/aiController.cjs

@@ -3,68 +3,90 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.setKnownMicroservicesHandler = exports.getKnownMicroservicesHandler = exports.answerQuestion = void 0;
-var _agent = require("./agent.cjs");
-var _knownMicroservices = require("./knownMicroservices.cjs");
-var _logger = _interopRequireDefault(require("../utils/logger.cjs"));
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-const answerQuestion = oasTlmConfig => async (req, res) => {
+exports.createConversation = createConversation;
+exports.deleteConversation = deleteConversation;
+exports.getConversationHistory = getConversationHistory;
+exports.listConversations = listConversations;
+exports.sendMessage = sendMessage;
+var _aiService = require("./aiService.cjs");
+async function createConversation(req, res) {
   try {
-    const {
-      question
-    } = req.body;
-    if (!question) res.status(400).json({
-      error: 'Missing question'
-    });
-    const getAgentResponse = (0, _agent.getAgent)(oasTlmConfig);
-    const answer = await getAgentResponse(question);
-    res.json({
-      answer
+    const conversation = (0, _aiService.getAiService)().createConversation();
+    res.status(201).json(conversation);
+  } catch (err) {
+    res.status(500).json({
+      error: err.message
     });
-  } catch (error) {
-    _logger.default.error(error);
+  }
+}
+async function listConversations(req, res) {
+  try {
+    // Only return id and name for each conversation
+    const conversations = (0, _aiService.getAiService)().listConversationsMinimal();
+    res.json(conversations);
+  } catch (err) {
     res.status(500).json({
-      error: 'Internal error'
+      error: err.message
     });
   }
-};
-exports.answerQuestion = answerQuestion;
-const setKnownMicroservicesHandler = () => (req, res) => {
+}
+async function getConversationHistory(req, res) {
   try {
     const {
-      microservices
-    } = req.body;
-    if (!Array.isArray(microservices)) {
-      res.status(400).json({
-        error: 'Invalid microservices format. Expected an array.'
+      conversationId
+    } = req.params;
+    const conversation = (0, _aiService.getAiService)().getConversation(conversationId);
+    if (!conversation) {
+      res.status(404).json({
+        error: 'Not found'
       });
       return;
     }
-    (0, _knownMicroservices.setKnownMicroservices)(microservices);
-    res.json({
-      message: "Microservices configuration updated successfully.",
-      knownMicroservices: (0, _knownMicroservices.getKnownMicroservices)(),
-      note: "In the future, OAS-Telemetry will support autodiscovery, making this configuration unnecessary."
-    });
-  } catch (error) {
-    _logger.default.error(error);
+    res.json(conversation);
+  } catch (err) {
     res.status(500).json({
-      error: 'Internal error'
+      error: err.message
     });
   }
-};
-exports.setKnownMicroservicesHandler = setKnownMicroservicesHandler;
-const getKnownMicroservicesHandler = () => (req, res) => {
+}
+async function deleteConversation(req, res) {
   try {
-    const microservices = (0, _knownMicroservices.getKnownMicroservices)();
-    res.json({
-      knownMicroservices: microservices
+    const {
+      conversationId
+    } = req.params;
+    const deleted = (0, _aiService.getAiService)().deleteConversation(conversationId);
+    if (!deleted) {
+      res.status(404).json({
+        error: 'Not found'
+      });
+      return;
+    }
+    res.status(204).send();
+  } catch (err) {
+    res.status(500).json({
+      error: err.message
     });
-  } catch (error) {
-    _logger.default.error(error);
+  }
+}
+async function sendMessage(req, res) {
+  try {
+    const {
+      conversationId
+    } = req.params;
+    const {
+      content
+    } = req.body;
+    if (!content) {
+      res.status(400).json({
+        error: 'Missing content'
+      });
+      return;
+    }
+    const messages = await (0, _aiService.getAiService)().sendMessage(conversationId, content);
+    res.json(messages);
+  } catch (err) {
     res.status(500).json({
-      error: 'Internal error'
+      error: err.message
     });
   }
-};
-exports.getKnownMicroservicesHandler = getKnownMicroservicesHandler;
+}

package/dist/cjs/tlm-ai/aiRoutes.cjs

@@ -6,11 +6,18 @@ Object.defineProperty(exports, "__esModule", {
 exports.getAIRoutes = void 0;
 var _express = require("express");
 var _aiController = require("./aiController.cjs");
+var _aiService = require("./aiService.cjs");
 const getAIRoutes = oasTlmConfig => {
   const router = (0, _express.Router)();
-  router.post('/chat', (0, _aiController.answerQuestion)(oasTlmConfig));
-  router.post('/microservices', (0, _aiController.setKnownMicroservicesHandler)());
-  router.get('/microservices', (0, _aiController.getKnownMicroservicesHandler)());
+  (0, _aiService.configureAiService)(oasTlmConfig); //oasTlmConfig.ai.openAIKey
+  router.get('/chat/health', (req, res) => {
+    res.status(200).send('AI service is healthy');
+  });
+  router.get('/chat', _aiController.listConversations);
+  router.post('/chat', _aiController.createConversation);
+  router.get('/chat/:conversationId', _aiController.getConversationHistory);
+  router.post('/chat/:conversationId/message', _aiController.sendMessage);
+  router.delete('/chat/:conversationId', _aiController.deleteConversation);
   return router;
 };
 exports.getAIRoutes = getAIRoutes;

package/dist/cjs/tlm-ai/aiService.cjs

@@ -0,0 +1,109 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.configureAiService = configureAiService;
+exports.getAiService = getAiService;
+var _openai = _interopRequireDefault(require("openai"));
+var _agent = require("./agent.cjs");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class AIService {
+  constructor(config) {
+    this.config = config;
+    this.conversations = new Map();
+    this.openai = new _openai.default({
+      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 (0, _agent.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;
+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
+  });
+}
+function getAiService() {
+  if (!aiService) throw new Error('AI Service not configured');
+  return aiService;
+}

package/dist/cjs/tlm-ai/tools.cjs

@@ -4,9 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.tools = exports.availableTools = void 0;
-var _axios = _interopRequireDefault(require("axios"));
 var _logger = _interopRequireDefault(require("../utils/logger.cjs"));
-var _knownMicroservices = require("./knownMicroservices.cjs");
 var _telemetryRegistry = require("../telemetry/telemetryRegistry.cjs");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 const getTraces = async searchInput => {
@@ -32,31 +30,22 @@ const getTraces = async searchInput => {
 const getLogs = async (startDate, endDate) => {
   _logger.default.debug("getLogs called with startDate:", startDate, "endDate:", endDate);
   try {
-    let nedbQuery = {};
-    if (!startDate && !endDate) {
-      _logger.default.debug("No date range provided, fetching all logs.");
-    } else {
-      _logger.default.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) => {
-      _telemetryRegistry.inMemoryDbLogExporter.find(nedbQuery, null, (err, docs) => {
-        if (err) {
-          reject(err);
-        } else {
-          logs.push(...docs);
-          _logger.default.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.default.debug(`Fetching logs from ${startEpoch} to ${endEpoch}`);
+    const nedbQuery = {
+      timestamp: {
+        $gte: startEpoch,
+        $lte: endEpoch
+      }
+    };
+    const logs = (await _telemetryRegistry.inMemoryDbLogExporter.find({
+      query: nedbQuery,
+      messageSearch: null,
+      limit: 50 // or any appropriate limit
+    })) || [];
+    _logger.default.debug(`Found ${logs.length} logs in the specified range.`);
     const simplifiedLogs = getSimplifiedLogs(logs);
     return {
       logs: simplifiedLogs
@@ -66,34 +55,6 @@ const getLogs = async (startDate, endDate) => {
     throw error;
   }
 };
-const getMetrics = async searchInput => {
-  _logger.default.debug("getMetrics called with searchInput:", searchInput);
-  try {
-    const search = searchInput || {};
-    const metrics = await new Promise((resolve, reject) => {
-      _telemetryRegistry.inMemoryDbMetricExporter.find(search, (err, docs) => {
-        if (err) reject(err);else resolve(docs || []);
-      });
-    });
-    const simplifiedMetrics = getSimplifiedMetrics(metrics);
-    _logger.default.debug(`Searching for metrics with searchInput: ${JSON.stringify(search)}`);
-    _logger.default.debug(`Metrics found: ${JSON.stringify(simplifiedMetrics.length)}`);
-    return {
-      metrics: simplifiedMetrics
-    };
-  } catch (error) {
-    _logger.default.error('Error fetching metrics:', error);
-    throw error;
-  }
-};
-const getCurrentTimestampInEpoch = () => {
-  _logger.default.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.default.debug("Starting telemetry...");
   _telemetryRegistry.inMemoryDbSpanExporter.enable();
@@ -120,29 +81,13 @@ const getTelemetryStatus = () => {
     metricsEnabled: _telemetryRegistry.inMemoryDbMetricExporter.isEnabled()
   };
 };
-const talkToExternalMicroserviceAgent = async (message, microserviceId) => {
-  _logger.default.debug("talkToExternalMicroserviceAgent called with question:", message, "microservice:", microserviceId);
-  const knownMicroservices = (0, _knownMicroservices.getKnownMicroservices)();
-  const identifiedMicroservice = knownMicroservices.find(m => m.id === microserviceId);
-  if (!identifiedMicroservice) {
-    _logger.default.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.default.post(identifiedMicroservice.url, {
-    question: message
-  });
+const getCurrentDate = () => {
+  _logger.default.debug("Getting the current date in ISO format...");
+  const now = new Date();
   return {
-    microservice: microserviceId,
-    response: microserviceResponse.data
+    currentDateISO: now.toISOString()
   };
 };
-const getMicroserviceAgents = () => {
-  _logger.default.debug("Getting microservice agents...");
-  return (0, _knownMicroservices.getKnownMicroservices)();
-};
 const tools = exports.tools = [{
   type: "function",
   function: {
@@ -231,7 +176,8 @@ const tools = exports.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",
@@ -250,54 +196,6 @@ const tools = exports.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: {
@@ -333,158 +231,21 @@ const tools = exports.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):
-        ${(0, _knownMicroservices.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: {}
   }
 }];
 const availableTools = exports.availableTools = {
   getTraces,
   getLogs,
-  getMetrics,
   startTelemetry,
   stopTelemetry,
   resetTelemetry,
   getTelemetryStatus,
-  getCurrentTimestampInEpoch,
-  talkToExternalMicroserviceAgent,
-  getMicroserviceAgents
+  getCurrentDate
 };
-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 {
@@ -502,10 +263,11 @@ 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
   }));
 }