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

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

@@ -0,0 +1,79 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getAgentResponse = getAgentResponse;
+var _openai = _interopRequireDefault(require("openai"));
+var _dotenv = _interopRequireDefault(require("dotenv"));
+var _tools = require("./tools.cjs");
+var _logger = _interopRequireDefault(require("../utils/logger.cjs"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+_dotenv.default.config();
+let openai;
+try {
+  openai = new _openai.default({
+    apiKey: process.env.OASTLM_AI_OPENAI_API_KEY,
+    dangerouslyAllowBrowser: true
+  });
+} catch {
+  openai = null;
+}
+const messages = [{
+  role: "assistant",
+  content: "You are a helpful telemetry assistant. Only use the functions you have been provided with. If the question is not related to the functions, respond with 'I cannot help with that.'. If you need to call to other agents, do so using the tools provided."
+}];
+async function agent(userInput) {
+  messages.push({
+    role: "user",
+    content: userInput
+  });
+  for (let i = 0; i < 5; i++) {
+    const response = await openai?.chat?.completions?.create?.({
+      model: process.env.OASTLM_AI_OPENAI_MODEL_NAME || "gpt-4o-mini",
+      messages: messages,
+      tools: _tools.tools
+    });
+    const {
+      finish_reason,
+      message
+    } = response.choices[0];
+    if (finish_reason === "tool_calls" && message.tool_calls) {
+      _logger.default.debug("Tool calls detected:", message.tool_calls);
+      const results = [];
+      for (const toolCall of message.tool_calls) {
+        const functionName = toolCall.function.name;
+        const functionToCall = _tools.availableTools[functionName];
+        const functionArgs = JSON.parse(toolCall.function.arguments);
+        const functionArgsArr = Object.values(functionArgs);
+        // @ts-expect-error yes
+        // eslint-disable-next-line prefer-spread
+        const functionResponse = await functionToCall.apply(null, functionArgsArr);
+        results.push({
+          name: functionName,
+          response: functionResponse
+        });
+      }
+      const resultMessage = results.map(({
+        name,
+        response
+      }) => `Result from "${name}":\n${JSON.stringify(response, null, 2)}`).join("\n\n");
+      messages.push({
+        role: "function",
+        name: "multiple_tool_calls",
+        content: resultMessage
+      });
+    } else if (finish_reason === "stop") {
+      messages.push(message);
+      return message;
+    }
+  }
+  return {
+    content: "Se alcanzó el número máximo de iteraciones sin una respuesta adecuada. Intenta con una consulta más específica."
+  };
+}
+async function getAgentResponse(question) {
+  const response = await agent(question);
+  _logger.default.debug("Response from agent:", response);
+  return response.content;
+}

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

@@ -0,0 +1,69 @@
+"use strict";
+
+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 = async (req, res) => {
+  try {
+    const {
+      question
+    } = req.body;
+    if (!question) res.status(400).json({
+      error: 'Missing question'
+    });
+    const answer = await (0, _agent.getAgentResponse)(question);
+    res.json({
+      answer
+    });
+  } catch (error) {
+    _logger.default.error(error);
+    res.status(500).json({
+      error: 'Internal error'
+    });
+  }
+};
+exports.answerQuestion = answerQuestion;
+const setKnownMicroservicesHandler = (req, res) => {
+  try {
+    const {
+      microservices
+    } = req.body;
+    if (!Array.isArray(microservices)) {
+      res.status(400).json({
+        error: 'Invalid microservices format. Expected an array.'
+      });
+      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.status(500).json({
+      error: 'Internal error'
+    });
+  }
+};
+exports.setKnownMicroservicesHandler = setKnownMicroservicesHandler;
+const getKnownMicroservicesHandler = (req, res) => {
+  try {
+    const microservices = (0, _knownMicroservices.getKnownMicroservices)();
+    res.json({
+      knownMicroservices: microservices
+    });
+  } catch (error) {
+    _logger.default.error(error);
+    res.status(500).json({
+      error: 'Internal error'
+    });
+  }
+};
+exports.getKnownMicroservicesHandler = getKnownMicroservicesHandler;

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

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.aiRoutes = void 0;
+var _express = require("express");
+var _aiController = require("./aiController.cjs");
+const aiRoutes = exports.aiRoutes = (0, _express.Router)();
+aiRoutes.post('/chat', _aiController.answerQuestion);
+aiRoutes.post('/microservices', _aiController.setKnownMicroservicesHandler); // New route for configuring microservices
+aiRoutes.get('/microservices', _aiController.getKnownMicroservicesHandler); // Route to retrieve the list of known microservices
+var _default = exports.default = aiRoutes;

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

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.setKnownMicroservices = exports.getKnownMicroservices = void 0;
+let knownMicroservices = null;
+const getKnownMicroservices = () => knownMicroservices || [];
+exports.getKnownMicroservices = getKnownMicroservices;
+const setKnownMicroservices = microservices => {
+  knownMicroservices = microservices;
+};
+exports.setKnownMicroservices = setKnownMicroservices;

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

@@ -0,0 +1,504 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.tools = exports.availableTools = void 0;
+var _axios = _interopRequireDefault(require("axios"));
+var _config = require("../config.cjs");
+var _logger = _interopRequireDefault(require("../utils/logger.cjs"));
+var _knownMicroservices = require("./knownMicroservices.cjs");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const getTraces = async searchInput => {
+  _logger.default.debug("getTraces called with searchInput:", searchInput);
+  try {
+    const search = searchInput || {};
+    const traces = await new Promise((resolve, reject) => {
+      _config.globalOasTlmConfig.dynamicSpanExporter.exporter.find(search, (err, docs) => {
+        if (err) reject(err);else resolve(docs);
+      });
+    });
+    const simplifiedTraces = getSimplifiedTraces(traces);
+    _logger.default.debug(`Searching for traces with searchInput: ${JSON.stringify(search)}`);
+    _logger.default.debug(`Traces found: ${JSON.stringify(simplifiedTraces.length)}`);
+    return {
+      traces: simplifiedTraces
+    };
+  } catch (error) {
+    _logger.default.error('Error fetching traces:', error);
+    throw error;
+  }
+};
+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) => {
+      _config.globalOasTlmConfig.debugExporter.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();
+        }
+      });
+    });
+    const simplifiedLogs = getSimplifiedLogs(logs);
+    return {
+      logs: simplifiedLogs
+    };
+  } catch (error) {
+    _logger.default.error('Error fetching logs:', error);
+    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) => {
+      _config.globalOasTlmConfig.metricsExporter.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...");
+  _config.globalOasTlmConfig.dynamicSpanExporter.exporter.start();
+};
+const stopTelemetry = () => {
+  _logger.default.debug("Stopping telemetry...");
+  _config.globalOasTlmConfig.dynamicSpanExporter.exporter.stop();
+};
+const resetTelemetry = () => {
+  _logger.default.debug("Resetting telemetry...");
+  _config.globalOasTlmConfig.dynamicSpanExporter.exporter.reset();
+};
+const getTelemetryStatus = () => {
+  _logger.default.debug("Getting telemetry status...");
+  const isRunning = _config.globalOasTlmConfig.dynamicSpanExporter.exporter.isRunning() || false;
+  return {
+    active: isRunning
+  };
+};
+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
+  });
+  return {
+    microservice: microserviceId,
+    response: microserviceResponse.data
+  };
+};
+const getMicroserviceAgents = () => {
+  _logger.default.debug("Getting microservice agents...");
+  return (0, _knownMicroservices.getKnownMicroservices)();
+};
+const tools = exports.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):
+        ${(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.`,
+    parameters: {}
+  }
+}];
+const availableTools = exports.availableTools = {
+  getTraces,
+  getLogs,
+  getMetrics,
+  startTelemetry,
+  stopTelemetry,
+  resetTelemetry,
+  getTelemetryStatus,
+  getCurrentTimestampInEpoch,
+  talkToExternalMicroserviceAgent,
+  getMicroserviceAgents
+};
+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
+  }));
+}