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

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/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;
+};