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

package/{src → dist/esm}/exporters/consoleExporter.js

@@ -1,47 +1,38 @@
-export class ConsoleExporter {
-
-    // PLUGIN SYSTEM -----------------------------------------------------------
-    plugins = [];
-
-    // OPEN TELEMETRY EXPORTER INTERFACE ---------------------------------------
-    export(readableSpans, resultCallback) {
-        console.log('ConsoleExporter | Received spans: ', readableSpans.length);
-        setTimeout(() => resultCallback({ code: 0 }), 0);
-    }
-
-    shutdown() {
-        return this.forceFlush();
-    }
-
-    forceFlush() {
-        return Promise.resolve();
-    }
-
-    // OAS-TOOLS OAS-TELEMETRY EXPORTER INTERFACE ---------------------------------------
-
-    start() {
-        console.log("Exporter started");
-    }
-
-    stop() {
-        console.log("Exporter stopped");
-    }
-
-    reset() {
-        console.log("Exporter reset");
-    }
-
-    isRunning() {
-        return true;
-    }
-
-    find(search, callback) {
-        console.log("Getting finished spans");
-        callback(null, []);
-        return [];
-    }
-
-    async getFinishedSpans() {
-        return [];
-    }
-}
+export class ConsoleExporter {
+    constructor() {
+        // PLUGIN SYSTEM -----------------------------------------------------------
+        this.plugins = [];
+    }
+    // OPEN TELEMETRY EXPORTER INTERFACE ---------------------------------------
+    export(readableSpans, resultCallback) {
+        console.log('ConsoleExporter | Received spans: ', readableSpans.length);
+        setTimeout(() => resultCallback({ code: 0 }), 0);
+    }
+    shutdown() {
+        return this.forceFlush();
+    }
+    forceFlush() {
+        return Promise.resolve();
+    }
+    // OAS-TOOLS OAS-TELEMETRY EXPORTER INTERFACE ---------------------------------------
+    start() {
+        console.log("Exporter started");
+    }
+    stop() {
+        console.log("Exporter stopped");
+    }
+    reset() {
+        console.log("Exporter reset");
+    }
+    isRunning() {
+        return true;
+    }
+    find(search, callback) {
+        console.log("Getting finished spans");
+        callback(null, []);
+        return [];
+    }
+    getFinishedSpans() {
+        return [];
+    }
+}

package/{src → dist/esm}/exporters/dynamicExporter.js

@@ -1,62 +1,50 @@
-import { ConsoleExporter } from "./consoleExporter.js";
-
-
-/**
- * DynamicExporter is a class that can be used to dynamically change the exporter used by OpenTelemetry.
- * This is useful when you want to change the exporter at runtime.
- * Links start, stop and export methods to the Real exporter.
- */
-export class DynamicExporter {
-
-    exporter;
-    /** 
-     * @returns {Array<PluginResource>} Returns the list of plugins registered in the exporter
-     */
-    getPlugins() {
-        return this.exporter.plugins;
-    }
-
-    /**
-     * Registers a plugin in the exporter
-     * @param {PluginResource} pluginResource The plugin to be registered
-     * @returns {void}
-     */
-    pushPlugin(pluginResource) {
-        if (!this.exporter.plugins) {
-            this.exporter.plugins = [];
-        }
-        this.exporter.plugins.push(pluginResource);
-    }
-    activatePlugin(pluginId) {
-        let plugins = this.exporter.plugins;
-        if (plugins) {
-            // plugin.active = true;
-            plugins.forEach(plugin => {
-                if (plugin.id === pluginId) {
-                    plugin.active = true;
-                }
-            });
-        }
-    }
-
-
-    constructor() {
-        let defaultExporter = new ConsoleExporter();
-        this.exporter = defaultExporter;
-        this.export = (readableSpans, resultCallback) => defaultExporter.export(readableSpans, resultCallback);
-        this.shutdown = () => defaultExporter.shutdown();
-        this.forceFlush = () => defaultExporter.forceFlush();
-    }
-
-    changeExporter(newExporter) {
-        this.exporter = newExporter;
-        // OpenTelemetry methods
-        this.export = (readableSpans, resultCallback) => newExporter.export(readableSpans, resultCallback);
-        this.shutdown = () => newExporter.shutdown();
-        this.forceFlush = () => newExporter.forceFlush();
-        // Other methods should be called directly from the exporter: globalOasTlmConfig.dynamicExporter.exporter.method()
-    }
-
-}
-
-export default DynamicExporter;
+import { ConsoleExporter } from "./consoleExporter.js";
+/**
+ * DynamicExporter is a class that can be used to dynamically change the exporter used by OpenTelemetry.
+ * This is useful when you want to change the exporter at runtime.
+ * Links start, stop and export methods to the Real exporter.
+ */
+export class DynamicExporter {
+    /**
+     * Returns the list of plugins registered in the exporter
+     */
+    getPlugins() {
+        return this.exporter.plugins;
+    }
+    /**
+     * Registers a plugin in the exporter
+     */
+    pushPlugin(pluginResource) {
+        if (!this.exporter.plugins) {
+            this.exporter.plugins = [];
+        }
+        this.exporter.plugins.push(pluginResource);
+    }
+    activatePlugin(pluginId) {
+        const plugins = this.exporter.plugins;
+        if (plugins) {
+            // plugin.active = true;
+            plugins.forEach((plugin) => {
+                if (plugin.id === pluginId) {
+                    plugin.active = true;
+                }
+            });
+        }
+    }
+    constructor() {
+        const defaultExporter = new ConsoleExporter();
+        this.exporter = defaultExporter;
+        this.export = (readableSpans, resultCallback) => defaultExporter.export(readableSpans, resultCallback);
+        this.shutdown = () => defaultExporter.shutdown();
+        this.forceFlush = () => defaultExporter.forceFlush();
+    }
+    changeExporter(newExporter) {
+        this.exporter = newExporter;
+        // OpenTelemetry methods
+        this.export = (readableSpan, resultCallback) => newExporter.export(readableSpan, resultCallback);
+        this.shutdown = () => newExporter.shutdown();
+        this.forceFlush = () => newExporter.forceFlush();
+        // Other methods should be called directly from the exporter: globalOasTlmConfig.dynamicSpanExporter.exporter.method()
+    }
+}
+export default DynamicExporter;

package/dist/esm/index.js

@@ -0,0 +1,39 @@
+import './instrumentation/index.js';
+import { globalOasTlmConfig } from './config.js';
+import { Router } from 'express';
+import { InMemoryExporter } from './exporters/InMemoryDbExporter.js';
+import logger from './utils/logger.js';
+import { configureRoutes } from './tlmRoutes.js';
+/**
+ * Returns the Oas Telemetry middleware. The parameters are the same as `globalOasTlmConfig`.
+ * All parameters are optional. However, either `spec` or `specFileName` must be provided to enable endpoint filtering.
+ */
+export default function oasTelemetry(oasTlmInputConfig) {
+    const router = Router();
+    if (process.env.OASTLM_MODULE_DISABLED === 'true') {
+        return router;
+    }
+    if (oasTlmInputConfig) {
+        logger.info("User provided config");
+        // Override global config with user provided config
+        for (const key in globalOasTlmConfig) {
+            globalOasTlmConfig[key] = oasTlmInputConfig[key] ?? globalOasTlmConfig[key];
+        }
+    }
+    logger.info("BaseURL: ", globalOasTlmConfig.baseURL);
+    globalOasTlmConfig.dynamicSpanExporter.changeExporter(globalOasTlmConfig.exporter ?? new InMemoryExporter());
+    if (globalOasTlmConfig.spec)
+        logger.info(`Spec content provided`);
+    else {
+        if (globalOasTlmConfig.specFileName != "")
+            logger.info(`Spec file used for telemetry: ${globalOasTlmConfig.specFileName}`);
+        else {
+            console.error("No spec available !");
+        }
+    }
+    if (globalOasTlmConfig.autoActivate) {
+        globalOasTlmConfig.dynamicSpanExporter.exporter?.start();
+    }
+    configureRoutes(router);
+    return router;
+}

package/dist/esm/instrumentation/index.js

@@ -0,0 +1,26 @@
+// import { NodeSDK } from '@opentelemetry/sdk-node';
+import { resourceFromAttributes } from '@opentelemetry/resources';
+import { HttpInstrumentation } from '@opentelemetry/instrumentation-http';
+import { ATTR_SERVICE_NAME } from '@opentelemetry/semantic-conventions';
+import logger from '../utils/logger.js';
+import { initializeLogs } from './logs.js';
+import { initializeTraces } from './traces.js';
+import { registerInstrumentations } from '@opentelemetry/instrumentation';
+import { initializeMetrics } from './metrics.js';
+const oasTelemetryResource = resourceFromAttributes({
+    [ATTR_SERVICE_NAME]: 'oas-telemetry-service'
+});
+if (process.env.OASTLM_MODULE_DISABLED !== 'true') {
+    initializeTraces(oasTelemetryResource);
+    initializeMetrics(oasTelemetryResource);
+    initializeLogs(oasTelemetryResource);
+    registerInstrumentations({
+        instrumentations: [
+            new HttpInstrumentation(),
+            // new ExpressInstrumentation(),
+        ],
+    });
+}
+else {
+    logger.info('🚫 OASTLM module is disabled, SDKs not initialized.');
+}

package/dist/esm/instrumentation/logs.js

@@ -0,0 +1,34 @@
+import { LoggerProvider, SimpleLogRecordProcessor } from '@opentelemetry/sdk-logs';
+import { SeverityNumber } from '@opentelemetry/api-logs';
+import { globalOasTlmConfig } from '../config.js';
+import logger from '../utils/logger.js';
+export function initializeLogs(resource) {
+    // Create and configure LoggerProvider
+    const logExporter = globalOasTlmConfig.logExporter;
+    const logRecordProcessor = new SimpleLogRecordProcessor(logExporter);
+    const loggerProvider = new LoggerProvider({ resource: resource, processors: [logRecordProcessor] });
+    // Get a logger instance
+    const loggerInstance = loggerProvider.getLogger('oas-telemetry'); // Use loggerProvider to get the logger
+    // Override console methods to emit logs via OpenTelemetry
+    const originalConsoleMethods = {
+        log: console.log,
+        warn: console.warn,
+        error: console.error,
+        info: console.info,
+        debug: console.debug,
+    };
+    Object.keys(originalConsoleMethods).forEach((method) => {
+        // @ts-expect-error yes
+        console[method] = (...args) => {
+            loggerInstance.emit({
+                severityNumber: SeverityNumber[method.toUpperCase()] || SeverityNumber.INFO,
+                severityText: method.toUpperCase(),
+                body: args.join(' '),
+                attributes: { 'source.source': `console.${method}` },
+            });
+            // @ts-expect-error yes
+            originalConsoleMethods[method](...args);
+        };
+    });
+    logger.info('✅ OpenTelemetry Logs initialized.');
+}

package/dist/esm/instrumentation/metrics.js

@@ -0,0 +1,18 @@
+import { MeterProvider, PeriodicExportingMetricReader } from '@opentelemetry/sdk-metrics';
+import logger from '../utils/logger.js';
+import { globalOasTlmConfig } from '../config.js';
+import { HostMetrics } from '@opentelemetry/host-metrics';
+export function initializeMetrics(resource) {
+    const metricReader = new PeriodicExportingMetricReader({
+        // exporter: new ConsoleMetricExporter(),
+        exporter: globalOasTlmConfig.metricsExporter,
+        exportIntervalMillis: globalOasTlmConfig.metricsExporterInterval
+    });
+    const meterProvider = new MeterProvider({
+        resource: resource,
+        readers: [metricReader],
+    });
+    const hostMetrics = new HostMetrics({ meterProvider });
+    hostMetrics.start();
+    logger.info('✅ OpenTelemetry Metrics initialized.');
+}

package/dist/esm/instrumentation/traces.js

@@ -0,0 +1,12 @@
+import logger from '../utils/logger.js';
+import { NodeTracerProvider, BatchSpanProcessor } from '@opentelemetry/sdk-trace-node';
+import { globalOasTlmConfig } from '../config.js';
+export function initializeTraces(resource) {
+    const tracerProvider = new NodeTracerProvider({
+        resource: resource,
+        spanProcessors: [new BatchSpanProcessor(globalOasTlmConfig.dynamicSpanExporter)]
+    });
+    // tracerProvider.addSpanProcessor();
+    tracerProvider.register();
+    logger.info('✅ OpenTelemetry Traces initialized.');
+}

package/{src → dist/esm}/openTelemetry.js

@@ -1,58 +1,50 @@
-import { NodeSDK } from '@opentelemetry/sdk-node';
-// import { getNodeAutoInstrumentations } from '@opentelemetry/auto-instrumentations-node';
-import { Resource } from '@opentelemetry/resources';
-import { HttpInstrumentation } from '@opentelemetry/instrumentation-http';
-import { globalOasTlmConfig } from './config.js';
-import { getCpuUsageData, getProcessCpuUsageData, getMemoryData, getProcessMemoryData } from './systemMetrics.js'; // Import system metrics functions
-
-// DynamicExporter allows changing to any exporter at runtime;
-const traceExporter = globalOasTlmConfig.dynamicExporter;
-// Alternative 1: Using NodeSDK
-const sdk = new NodeSDK({
-  resource: new Resource({
-    service: 'oas-telemetry-service'
-  }),
-  traceExporter,
-  instrumentations: [new HttpInstrumentation()]
-});
-
-
-// Collect and export system metrics
-setInterval(() => {
-  const cpuUsageData = getCpuUsageData();
-  const processCpuUsageData = getProcessCpuUsageData();
-  const memoryData = getMemoryData();
-  const processMemoryData = getProcessMemoryData();
-
-  const metrics = {
-    timestamp: Date.now(), 
-    cpuUsageData,
-    processCpuUsageData,
-    memoryData,
-    processMemoryData,
-  };
-
-  // Export the collected metrics using the InMemoryDBMetricsExporter
-  const inMemoryDbMetricExporter = globalOasTlmConfig.metricsExporter;
-  inMemoryDbMetricExporter.export(metrics, (result) => {});
-}, globalOasTlmConfig.systemMetricsInterval);
-
-console.log('✅ OpenTelemetry System Metrics initialized.');
-
-if (process.env.OASTLM_MODULE_DISABLED !== 'true') {
-  sdk.start()
-}
-
-// Alternative 2:
-// const provider = new NodeTracerProvider();
-// provider.addSpanProcessor(new SimpleSpanProcessor(traceExporter));
-
-// if (process.env.OASTLM_MODULE_DISABLED !== 'true') {
-//   provider.register();
-//   registerInstrumentations({
-//     instrumentations: [
-//       new HttpInstrumentation(),
-//       new ExpressInstrumentation(),
-//     ],
-//   });
-// }
+import { NodeSDK } from '@opentelemetry/sdk-node';
+// import { getNodeAutoInstrumentations } from '@opentelemetry/auto-instrumentations-node';
+import { Resource } from '@opentelemetry/resources';
+import { HttpInstrumentation } from '@opentelemetry/instrumentation-http';
+import { globalOasTlmConfig } from './config.js';
+import { getCpuUsageData, getProcessCpuUsageData, getMemoryData, getProcessMemoryData } from './systemMetrics.js'; // Import system metrics functions
+import logger from './utils/logger.js';
+// DynamicExporter allows changing to any exporter at runtime;
+const dynamicSpanExporter = globalOasTlmConfig.dynamicSpanExporter;
+// Alternative 1: Using NodeSDK
+const sdk = new NodeSDK({
+    resource: new Resource({
+        service: 'oas-telemetry-service'
+    }),
+    traceExporter: dynamicSpanExporter,
+    instrumentations: [new HttpInstrumentation()]
+});
+// Collect and export system metrics
+setInterval(() => {
+    const cpuUsageData = getCpuUsageData();
+    const processCpuUsageData = getProcessCpuUsageData();
+    const memoryData = getMemoryData();
+    const processMemoryData = getProcessMemoryData();
+    const metrics = {
+        timestamp: Date.now(),
+        cpuUsageData,
+        processCpuUsageData,
+        memoryData,
+        processMemoryData,
+    };
+    // Export the collected metrics using the InMemoryDBMetricsExporter
+    const inMemoryDbMetricExporter = globalOasTlmConfig.metricsExporter;
+    inMemoryDbMetricExporter.export(metrics, () => { });
+}, globalOasTlmConfig.systemMetricsInterval);
+logger.info('✅ OpenTelemetry System Metrics initialized.');
+if (process.env.OASTLM_MODULE_DISABLED !== 'true') {
+    sdk.start();
+}
+// Alternative 2:
+// const provider = new NodeTracerProvider();
+// provider.addSpanProcessor(new SimpleSpanProcessor(traceExporter));
+// if (process.env.OASTLM_MODULE_DISABLED !== 'true') {
+//   provider.register();
+//   registerInstrumentations({
+//     instrumentations: [
+//       new HttpInstrumentation(),
+//       new ExpressInstrumentation(),
+//     ],
+//   });
+// }

package/dist/esm/systemMetrics.js

@@ -0,0 +1,82 @@
+import { cpus, totalmem, freemem } from 'os';
+const MILLISECOND = 1 / 1e3;
+const MICROSECOND = 1 / 1e6;
+let prevOsData = {
+    time: Date.now(),
+    cpus: cpus(),
+};
+export function getCpuUsageData() {
+    const currentTime = Date.now();
+    const timeElapsed = currentTime - prevOsData.time;
+    const currentOsData = { time: currentTime, cpus: cpus() };
+    const usageData = currentOsData.cpus.map((cpu, cpuNumber) => {
+        const prevTimes = prevOsData.cpus[cpuNumber].times;
+        const currTimes = cpu.times;
+        const idle = currTimes.idle * MILLISECOND;
+        const user = currTimes.user * MILLISECOND;
+        const system = currTimes.sys * MILLISECOND;
+        const interrupt = currTimes.irq * MILLISECOND;
+        const nice = currTimes.nice * MILLISECOND;
+        const idleP = (currTimes.idle - prevTimes.idle) / timeElapsed;
+        const userP = (currTimes.user - prevTimes.user) / timeElapsed;
+        const systemP = (currTimes.sys - prevTimes.sys) / timeElapsed;
+        const interruptP = (currTimes.irq - prevTimes.irq) / timeElapsed;
+        const niceP = (currTimes.nice - prevTimes.nice) / timeElapsed;
+        return {
+            cpuNumber: String(cpuNumber),
+            idle,
+            user,
+            system,
+            interrupt,
+            nice,
+            userP,
+            systemP,
+            idleP,
+            interruptP,
+            niceP,
+        };
+    });
+    prevOsData = currentOsData;
+    return usageData;
+}
+let prevProcData = {
+    time: Date.now(),
+    usage: process.cpuUsage(),
+};
+export function getProcessCpuUsageData() {
+    const currentTime = Date.now();
+    const currentUsage = process.cpuUsage();
+    const prevUsage = prevProcData.usage;
+    const timeElapsed = (currentTime - prevProcData.time) * 1000;
+    const cpusTimeElapsed = timeElapsed * prevOsData.cpus.length;
+    const user = currentUsage.user * MICROSECOND;
+    const system = currentUsage.system * MICROSECOND;
+    const userP = (currentUsage.user - prevUsage.user) / cpusTimeElapsed;
+    const systemP = (currentUsage.system - prevUsage.system) / cpusTimeElapsed;
+    prevProcData = { time: currentTime, usage: currentUsage };
+    return {
+        user,
+        system,
+        userP,
+        systemP,
+    };
+}
+export function getMemoryData() {
+    const total = totalmem();
+    const free = freemem();
+    const used = total - free;
+    const freeP = free / total;
+    const usedP = used / total;
+    return {
+        used,
+        free,
+        usedP,
+        freeP,
+    };
+}
+export function getProcessMemoryData() {
+    if (process.memoryUsage().rss) {
+        return process.memoryUsage().rss;
+    }
+    return 0;
+}

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

@@ -0,0 +1,68 @@
+import OpenAI from 'openai';
+import dotenv from 'dotenv';
+import { tools, availableTools } from './tools.js';
+import logger from '../utils/logger.js';
+dotenv.config();
+let openai;
+try {
+    openai = new OpenAI({
+        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,
+        }));
+        const { finish_reason, message } = response.choices[0];
+        if (finish_reason === "tool_calls" && message.tool_calls) {
+            logger.debug("Tool calls detected:", message.tool_calls);
+            const results = [];
+            for (const toolCall of message.tool_calls) {
+                const functionName = toolCall.function.name;
+                const functionToCall = 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." };
+}
+export async function getAgentResponse(question) {
+    const response = await agent(question);
+    logger.debug("Response from agent:", response);
+    return response.content;
+}

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

@@ -0,0 +1,45 @@
+import { getAgentResponse } from './agent.js';
+import { setKnownMicroservices, getKnownMicroservices } from './knownMicroservices.js';
+import logger from '../utils/logger.js';
+export const answerQuestion = async (req, res) => {
+    try {
+        const { question } = req.body;
+        if (!question)
+            res.status(400).json({ error: 'Missing question' });
+        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) => {
+    try {
+        const { microservices } = req.body;
+        if (!Array.isArray(microservices)) {
+            res.status(400).json({ error: 'Invalid microservices format. Expected an array.' });
+            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) => {
+    try {
+        const microservices = getKnownMicroservices();
+        res.json({ knownMicroservices: microservices });
+    }
+    catch (error) {
+        logger.error(error);
+        res.status(500).json({ error: 'Internal error' });
+    }
+};

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

@@ -0,0 +1,7 @@
+import { Router } from 'express';
+import { answerQuestion, setKnownMicroservicesHandler, getKnownMicroservicesHandler } from './aiController.js';
+export const aiRoutes = Router();
+aiRoutes.post('/chat', answerQuestion);
+aiRoutes.post('/microservices', setKnownMicroservicesHandler); // New route for configuring microservices
+aiRoutes.get('/microservices', getKnownMicroservicesHandler); // Route to retrieve the list of known microservices
+export default aiRoutes;

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

@@ -0,0 +1,5 @@
+let knownMicroservices = null;
+export const getKnownMicroservices = () => knownMicroservices || [];
+export const setKnownMicroservices = (microservices) => {
+    knownMicroservices = microservices;
+};