@oas-tools/oas-telemetry 0.7.1 → 0.8.0-alpha.1

package/dist/esm/tlm-metric/metricsController.js

@@ -1,70 +1,41 @@
 import { inMemoryDbMetricExporter } from '../telemetry/telemetryRegistry.js';
-import { convertRegexRecursively } from '../utils/regexUtils.js';
-export const listMetrics = async (req, res) => {
+import { importMetricsToMemory, sanitizeMetricRecords } from './metricsService.js';
+import { gzipSync } from 'zlib';
+export const getMetricsStats = async (req, res) => {
     try {
-        const metrics = inMemoryDbMetricExporter.getFinishedMetrics();
-        res.send({ metricsCount: metrics.length, metrics: metrics });
+        const stats = inMemoryDbMetricExporter.getStats();
+        res.send(stats);
     }
     catch (err) {
         console.error(err);
-        res.status(500).send({ error: 'Failed to list metrics data' });
+        res.status(500).send({ error: 'Failed to get metrics stats' });
     }
 };
-export const findMetrics = (req, res) => {
-    const body = req.body;
-    const query = body?.query ? body.query : {};
-    let processedQuery;
-    try {
-        processedQuery = convertRegexRecursively(query);
-    }
-    catch (error) {
-        console.error(error.message);
-        res.status(400).send({ error: error.message });
-        return; // Exit if invalid regex was encountered
-    }
-    inMemoryDbMetricExporter.find(processedQuery, (err, docs) => {
-        if (err) {
-            console.error(err);
-            res.status(404).send({ metricsCount: 0, metrics: [], error: err });
-            return;
-        }
-        const metrics = docs;
-        res.send({ metricsCount: metrics.length, metrics: metrics });
-    });
-};
 export const resetMetrics = (req, res) => {
     inMemoryDbMetricExporter.reset();
     res.send('Metrics reset');
 };
 export const insertMetricsToDb = async (req, res) => {
-    const jsonContent = req.body.metrics;
-    const resetData = req.query.reset === 'true';
-    if (!Array.isArray(jsonContent)) {
-        res.status(400).send({ error: 'Invalid data format.' });
-        return;
-    }
-    const cleanedMetrics = jsonContent.map((metric) => {
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        const { _id, ...rest } = metric; // Remove _id if it exists
-        return rest; // Return the cleaned metric object
-    });
     try {
+        const scopeMetricsData = (req.body || {}).scopeMetrics;
+        const resetData = req.query.reset === 'true';
+        const format = (req.body.format || req.query.format || 'raw');
+        if (!Array.isArray(scopeMetricsData)) {
+            res.status(400).send({ error: 'Invalid data format. Expected array in body.scopeMetrics' });
+            return;
+        }
+        const cleanedScopeMetrics = sanitizeMetricRecords(scopeMetricsData);
         let message = '';
+        importMetricsToMemory(cleanedScopeMetrics, { reset: resetData, format });
         if (resetData) {
-            inMemoryDbMetricExporter.reset();
             message += 'Metrics Database reset. ';
         }
-        await new Promise((resolve, reject) => {
-            inMemoryDbMetricExporter.insert(cleanedMetrics, (err, newDocs) => {
-                if (err) {
-                    console.error('Error inserting metrics:', err);
-                    return reject(err);
-                }
-                resolve(newDocs);
-            });
+        message += `Inserted ${cleanedScopeMetrics.length} scopeMetrics (format: ${format}).`;
+        res.send({
+            message,
+            scopeMetricsCount: cleanedScopeMetrics.length,
+            format
         });
-        message += `Inserted ${cleanedMetrics.length} metrics.`;
-        res.send({ message, InsertedMetricsCount: cleanedMetrics.length });
     }
     catch (err) {
         console.error(err);
@@ -84,7 +55,7 @@ export const statusMetrics = (req, res) => {
     res.send({ active: isRunning });
 };
 export const setMetricRetentionTime = (req, res) => {
-    const retentionTimeInSeconds = req.body.retentionTimeInSeconds;
+    const retentionTimeInSeconds = (req.body || {}).retentionTimeInSeconds;
     if (typeof retentionTimeInSeconds !== 'number' || retentionTimeInSeconds <= 0) {
         res.status(400).send({ error: 'Invalid retention time. Must be a positive number.' });
         return;
@@ -96,3 +67,98 @@ export const getMetricRetentionTime = (req, res) => {
     const retentionTimeInSeconds = inMemoryDbMetricExporter.retentionTimeInSeconds || 0;
     res.send({ retentionTimeInSeconds: retentionTimeInSeconds });
 };
+/**
+ * Find metrics by scope+metric queries with filters (POST /metrics/find or GET /metrics)
+ * All parameters are optional:
+ * - If scopeMetrics is not provided or empty, returns all metrics
+ * - If startTime/endTime not provided, returns all available data
+ * - format can be 'raw' (default) or 'otel'
+ */
+export const findMetrics = async (req, res) => {
+    try {
+        const { scopeMetrics, from, to, format } = req.body || {};
+        // Validate scopeMetrics structure if provided
+        if (scopeMetrics && Array.isArray(scopeMetrics)) {
+            for (const query of scopeMetrics) {
+                if (!query.scope || !query.scope.name || !query.descriptor || !query.descriptor.name) {
+                    res.status(400).json({
+                        error: 'Each query must have scope.name and descriptor.name defined'
+                    });
+                    return;
+                }
+            }
+        }
+        // Execute query
+        const response = inMemoryDbMetricExporter.find({
+            scopeMetrics: scopeMetrics && scopeMetrics.length > 0 ? scopeMetrics : undefined,
+            from,
+            to,
+            format: format || 'raw'
+        });
+        res.json({
+            format: format || 'raw',
+            scopeMetricsCount: response.results.length,
+            scopeMetrics: response.results,
+        });
+    }
+    catch (err) {
+        console.error(err);
+        res.status(500).json({ error: 'Failed to find metrics' });
+    }
+};
+export const exportMetrics = (req, res) => {
+    try {
+        const response = inMemoryDbMetricExporter.find({
+            format: 'raw'
+        });
+        const responseBody = {
+            format: 'raw',
+            scopeMetricsCount: response.results.length,
+            scopeMetrics: response.results,
+        };
+        const payload = JSON.stringify(responseBody);
+        const payloadSize = Buffer.byteLength(payload, 'utf-8');
+        const acceptsGzip = String(req.headers['accept-encoding'] || '').includes('gzip');
+        const timestamp = new Date().toISOString().slice(0, 19).replace(/[-T:]/g, '');
+        res.setHeader('Content-Type', 'application/json');
+        res.setHeader('Content-Disposition', `attachment; filename="metrics-${timestamp}.json"`);
+        res.setHeader('Vary', 'Accept-Encoding');
+        if (acceptsGzip && payloadSize > 64 * 1024) {
+            const compressed = gzipSync(payload);
+            res.setHeader('Content-Encoding', 'gzip');
+            res.setHeader('Content-Length', compressed.length.toString());
+            res.end(compressed);
+            return;
+        }
+        res.setHeader('Content-Length', payloadSize.toString());
+        res.end(payload);
+    }
+    catch (err) {
+        console.error('Failed to export metrics:', err);
+        res.status(500).send({ error: 'Failed to export metrics', details: err.message });
+    }
+};
+export const importMetrics = async (req, res) => {
+    const resetData = req.query.reset === 'true';
+    const body = req.body || {};
+    const format = (body.format || req.query.format || 'raw');
+    const importedScopeMetrics = Array.isArray(body) ? body : body.scopeMetrics;
+    try {
+        if (!Array.isArray(importedScopeMetrics)) {
+            res.status(400).send({ error: 'Invalid data format. Expected an array in request body or body.scopeMetrics.' });
+            return;
+        }
+        const cleanedMetrics = sanitizeMetricRecords(importedScopeMetrics);
+        importMetricsToMemory(cleanedMetrics, { reset: resetData, format });
+        let message = '';
+        if (resetData) {
+            message += 'Metrics Database reset. ';
+        }
+        message += `Imported ${cleanedMetrics.length} metrics (format: ${format}).`;
+        res.send({ message, ImportedMetricsCount: cleanedMetrics.length, format });
+    }
+    catch (err) {
+        console.error('Import failed:', err);
+        res.status(400).send({ error: 'Failed to import metrics', details: err.message });
+    }
+};

package/dist/esm/tlm-metric/metricsRoutes.js

@@ -1,5 +1,5 @@
 import { Router } from 'express';
-import { listMetrics, findMetrics, resetMetrics, insertMetricsToDb, startMetrics, stopMetrics, statusMetrics, setMetricRetentionTime, getMetricRetentionTime } from './metricsController.js';
+import { resetMetrics, insertMetricsToDb, startMetrics, stopMetrics, statusMetrics, setMetricRetentionTime, getMetricRetentionTime, getMetricsStats, findMetrics, exportMetrics, importMetrics, } from './metricsController.js';
 export const getMetricsRoutes = () => {
     const router = Router();
     // Metrics Control
@@ -9,9 +9,14 @@ export const getMetricsRoutes = () => {
     router.post('/reset', resetMetrics);
     router.post('/retention-time', setMetricRetentionTime);
     router.get('/retention-time', getMetricRetentionTime);
-    router.get('/', listMetrics);
-    router.post('/', insertMetricsToDb);
+    // Export/Import
+    router.get('/export', exportMetrics);
+    router.post('/import', importMetrics);
+    // Query endpoints
     router.post('/find', findMetrics);
+    router.get('/stats', getMetricsStats);
+    router.get('/', findMetrics);
+    router.post('/', insertMetricsToDb);
     return router;
 };
 export default getMetricsRoutes;

package/dist/esm/tlm-metric/metricsService.js

@@ -0,0 +1,22 @@
+import { inMemoryDbMetricExporter } from '../telemetry/telemetryRegistry.js';
+export function sanitizeMetricRecords(records) {
+    return records.map((record) => {
+        const { _id, ...rest } = record;
+        return rest;
+    });
+}
+export function importMetricsToMemory(records, options) {
+    if (options?.reset) {
+        inMemoryDbMetricExporter.reset();
+    }
+    if (!records.length) {
+        return 0;
+    }
+    if ((options?.format || 'raw') === 'otel') {
+        inMemoryDbMetricExporter.insertOtel(records);
+    }
+    else {
+        inMemoryDbMetricExporter.insertRaw(records);
+    }
+    return records.length;
+}

package/dist/esm/tlm-plugin/pluginController.js

@@ -5,7 +5,6 @@ import logger from "../utils/logger.js";
 import { pluginService } from "./pluginService.js";
 import { fileURLToPath } from "url";
 export const listPlugins = (req, res) => {
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
     const plugins = pluginService.getPlugins().map(({ process, ...rest }) => rest);
     res.send({
         pluginsCount: plugins.length,
@@ -56,16 +55,12 @@ export const registerPlugin = async (req, res) => {
         return;
     }
     const isCjs = typeof __filename !== "undefined" && typeof __dirname !== "undefined";
-    const __filenameUniversal = isCjs
-        ? __filename
-        : fileURLToPath(import.meta.url);
-    const __dirnameUniversal = isCjs
-        ? __dirname
-        : path.dirname(__filenameUniversal);
+    // @ts-ignore -- import.meta no existe en el build CJS
+    const currentDirectory = isCjs ? __dirname : path.dirname(fileURLToPath(import.meta.url));
     const pluginProcessFile = isCjs
         ? "pluginProcess.cjs"
         : "pluginProcess.js";
-    const child = fork(path.resolve(__dirnameUniversal, pluginProcessFile), [], {
+    const child = fork(path.resolve(currentDirectory, pluginProcessFile), [], {
         stdio: ["pipe", "pipe", "pipe", "ipc"],
     });
     child.stdout?.on("data", (data) => {
@@ -108,7 +103,7 @@ export const registerPlugin = async (req, res) => {
     });
 };
 export const activatePlugin = (req, res) => {
-    const { id } = req.params;
+    const id = req.params.id;
     const plugin = pluginService.getPlugins().find((p) => p.id === id);
     if (!plugin) {
         res.status(404).send(`Plugin with id "${id}" not found.`);
@@ -118,7 +113,7 @@ export const activatePlugin = (req, res) => {
     res.status(200).send(`Plugin "${id}" activated.`);
 };
 export const deactivatePlugin = (req, res) => {
-    const { id } = req.params;
+    const id = req.params.id;
     const plugin = pluginService.getPlugins().find((p) => p.id === id);
     if (!plugin) {
         res.status(404).send(`Plugin with id "${id}" not found.`);
@@ -128,7 +123,7 @@ export const deactivatePlugin = (req, res) => {
     res.status(200).send(`Plugin "${id}" deactivated.`);
 };
 export const deletePlugin = (req, res) => {
-    const { id } = req.params;
+    const id = req.params.id;
     const plugin = pluginService.getPlugins().find((p) => p.id === id);
     if (!plugin) {
         res.status(404).send(`Plugin with id "${id}" not found.`);

package/dist/esm/tlm-plugin/pluginService.js

@@ -1,9 +1,7 @@
 import logger from "../utils/logger.js";
 class PluginService {
-    constructor() {
-        this.plugins = [];
-        this.enabled = false;
-    }
+    plugins = [];
+    enabled = false;
     getPlugins() {
         return this.plugins;
     }

package/dist/esm/tlm-trace/traceController.js

@@ -1,22 +1,24 @@
 import { inMemoryDbSpanExporter } from '../telemetry/telemetryRegistry.js';
 import { convertRegexRecursively } from '../utils/regexUtils.js';
-export const startTraces = (req, res) => {
+import { importTracesToMemory, sanitizeTraceRecords } from './traceService.js';
+import { gzipSync } from 'zlib';
+export const startTraces = (_req, res) => {
     inMemoryDbSpanExporter.enable();
     res.send('Traces started');
 };
-export const stopTraces = (req, res) => {
+export const stopTraces = (_req, res) => {
     inMemoryDbSpanExporter.disable();
     res.send('Traces stopped');
 };
-export const statusTraces = (req, res) => {
+export const statusTraces = (_req, res) => {
     const isRunning = inMemoryDbSpanExporter.isEnabled() || false;
     res.send({ active: isRunning });
 };
-export const resetTraces = (req, res) => {
+export const resetTraces = (_req, res) => {
     inMemoryDbSpanExporter.reset();
     res.send('Traces reset');
 };
-export const listTraces = async (req, res) => {
+export const listTraces = async (_req, res) => {
     try {
         const spans = inMemoryDbSpanExporter.getFinishedSpans();
         res.send({ spansCount: spans.length, spans: spans });
@@ -26,55 +28,51 @@ export const listTraces = async (req, res) => {
         res.status(500).send({ error: 'Failed to list traces data' });
     }
 };
-export const findTraces = (req, res) => {
-    const body = req.body;
-    const query = body?.query ? body.query : {};
+export const findTraces = async (req, res) => {
+    const body = req.body || {};
+    const findQuery = body.query || {};
+    const limit = parseInt(body.limit) || 50;
+    const sortOrder = body.sort || null;
     let processedQuery;
     try {
-        processedQuery = convertRegexRecursively(query);
+        processedQuery = convertRegexRecursively(findQuery);
     }
     catch (error) {
         console.error(error.message);
         res.status(400).send({ error: error.message });
         return; // Exit if invalid regex was encountered
     }
-    inMemoryDbSpanExporter.find(processedQuery, (err, docs) => {
-        if (err) {
-            console.error(err);
-            res.status(400).send({ spansCount: 0, spans: [], error: err.message });
-            return; // Exit the function to prevent further execution
-        }
-        const spans = docs;
-        res.send({ spansCount: spans.length, spans: spans });
-    });
+    try {
+        const findConfig = {
+            query: processedQuery,
+            limit,
+            sortOrder
+        };
+        const docs = await inMemoryDbSpanExporter.find(findConfig);
+        res.send({
+            spansCount: docs.length,
+            spans: docs,
+        });
+    }
+    catch (err) {
+        console.error(err);
+        res.status(500).send({ spansCount: 0, spans: [], error: err.message });
+    }
 };
 export const insertTracesToDb = async (req, res) => {
-    const jsonContent = req.body.spans;
+    const jsonContent = (req.body || {}).spans;
     const resetData = req.query.reset === 'true';
     if (!Array.isArray(jsonContent)) {
         res.status(400).send({ error: 'Invalid data format.' });
         return;
     }
-    const cleanedTraces = jsonContent.map((trace) => {
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        const { _id, ...rest } = trace; // Remove _id if it exists
-        return rest; // Return the cleaned trace object
-    });
+    const cleanedTraces = sanitizeTraceRecords(jsonContent);
     try {
         let message = '';
+        await importTracesToMemory(cleanedTraces, { reset: resetData });
         if (resetData) {
-            inMemoryDbSpanExporter.reset();
             message += 'Traces Database reset. ';
         }
-        await new Promise((resolve, reject) => {
-            inMemoryDbSpanExporter.insert(cleanedTraces, (err, newDocs) => {
-                if (err) {
-                    console.error('Error inserting traces:', err);
-                    return reject(err);
-                }
-                resolve(newDocs);
-            });
-        });
         message += `Inserted ${cleanedTraces.length} traces.`;
         res.send({ message, InsertedTracesCount: cleanedTraces.length });
     }
@@ -83,8 +81,31 @@ export const insertTracesToDb = async (req, res) => {
         res.status(500).send({ error: 'Failed to reset and insert data', details: err.message });
     }
 };
+export const importTraces = async (req, res) => {
+    const resetData = req.query.reset === 'true';
+    const body = req.body || {};
+    const importedSpans = Array.isArray(body) ? body : body.spans;
+    try {
+        if (!Array.isArray(importedSpans)) {
+            res.status(400).send({ error: 'Invalid data format. Expected an array in request body or body.spans.' });
+            return;
+        }
+        const cleanedTraces = sanitizeTraceRecords(importedSpans);
+        let message = '';
+        await importTracesToMemory(cleanedTraces, { reset: resetData });
+        if (resetData) {
+            message += 'Traces Database reset. ';
+        }
+        message += `Imported ${cleanedTraces.length} traces.`;
+        res.send({ message, ImportedTracesCount: cleanedTraces.length });
+    }
+    catch (err) {
+        console.error('Import failed:', err);
+        res.status(400).send({ error: 'Failed to import traces', details: err.message });
+    }
+};
 export const setTraceRetentionTime = (req, res) => {
-    const retentionTimeInSeconds = req.body.retentionTimeInSeconds;
+    const retentionTimeInSeconds = (req.body || {}).retentionTimeInSeconds;
     if (typeof retentionTimeInSeconds !== 'number' || retentionTimeInSeconds <= 0) {
         res.status(400).send({ error: 'Invalid retention time. Must be a positive number.' });
         return;
@@ -92,7 +113,37 @@ export const setTraceRetentionTime = (req, res) => {
     inMemoryDbSpanExporter.retentionTimeInSeconds = retentionTimeInSeconds;
     res.send({ message: `Retention time set to ${retentionTimeInSeconds} seconds.` });
 };
-export const getTraceRetentionTime = (req, res) => {
+export const getTraceRetentionTime = (_req, res) => {
     const retentionTimeInSeconds = inMemoryDbSpanExporter.retentionTimeInSeconds || 0;
     res.send({ retentionTimeInSeconds: retentionTimeInSeconds });
 };
+export const exportTraces = async (req, res) => {
+    try {
+        const findConfig = {
+            query: {},
+            sortOrder: { startTime: -1 }
+        };
+        const docs = await inMemoryDbSpanExporter.find(findConfig);
+        const responseBody = { spansCount: docs.length, spans: docs };
+        const payload = JSON.stringify(responseBody);
+        const payloadSize = Buffer.byteLength(payload, 'utf-8');
+        const acceptsGzip = String(req.headers['accept-encoding'] || '').includes('gzip');
+        const timestamp = new Date().toISOString().slice(0, 19).replace(/[-T:]/g, '');
+        res.setHeader('Content-Type', 'application/json');
+        res.setHeader('Content-Disposition', `attachment; filename="traces-${timestamp}.json"`);
+        res.setHeader('Vary', 'Accept-Encoding');
+        if (acceptsGzip && payloadSize > 64 * 1024) {
+            const compressed = gzipSync(payload);
+            res.setHeader('Content-Encoding', 'gzip');
+            res.setHeader('Content-Length', compressed.length.toString());
+            res.end(compressed);
+            return;
+        }
+        res.setHeader('Content-Length', payloadSize.toString());
+        res.end(payload);
+    }
+    catch (err) {
+        console.error('Failed to export traces:', err);
+        res.status(500).send({ error: 'Failed to export traces', details: err.message });
+    }
+};

package/dist/esm/tlm-trace/traceRoutes.js

@@ -1,5 +1,5 @@
 import { Router } from 'express';
-import { startTraces, stopTraces, statusTraces, resetTraces, listTraces, findTraces, insertTracesToDb, setTraceRetentionTime, getTraceRetentionTime } from './traceController.js';
+import { startTraces, stopTraces, statusTraces, resetTraces, listTraces, findTraces, insertTracesToDb, importTraces, setTraceRetentionTime, getTraceRetentionTime, exportTraces } from './traceController.js';
 export const getTraceRoutes = () => {
     const router = Router();
     // Telemetry Control
@@ -7,6 +7,8 @@ export const getTraceRoutes = () => {
     router.post('/stop', stopTraces);
     router.get('/status', statusTraces);
     router.post('/reset', resetTraces);
+    router.get('/export', exportTraces);
+    router.post('/import', importTraces);
     router.get('/', listTraces);
     router.post('/', insertTracesToDb);
     router.post('/find', findTraces);

package/dist/esm/tlm-trace/traceService.js

@@ -0,0 +1,25 @@
+import { inMemoryDbSpanExporter } from '../telemetry/telemetryRegistry.js';
+export function sanitizeTraceRecords(records) {
+    return records.map((record) => {
+        const { _id, ...rest } = record;
+        return rest;
+    });
+}
+export async function importTracesToMemory(records, options) {
+    if (options?.reset) {
+        inMemoryDbSpanExporter.reset();
+    }
+    if (!records.length) {
+        return 0;
+    }
+    await new Promise((resolve, reject) => {
+        inMemoryDbSpanExporter.insert(records, (err) => {
+            if (err) {
+                reject(err);
+                return;
+            }
+            resolve();
+        });
+    });
+    return records.length;
+}

package/dist/esm/tlm-ui/uiRoutes.js

@@ -11,17 +11,17 @@ export const getUIRoutes = () => {
         relativePath = '../../dist/ui';
         logger.warn('🚧 This process is serving the OASTLM UI from the build directory, but you are in development mode. For live updates, run the React app separately and access it at http://localhost:5173/.');
     }
-    const customFilename = fileURLToPath(import.meta.url);
-    const customDirname = path.dirname(customFilename);
-    const staticFilesPath = path.join(customDirname, relativePath);
+    const isCjs = typeof __filename !== "undefined" && typeof __dirname !== "undefined";
+    // @ts-ignore -- import.meta no existe en el build CJS
+    const currentDirectory = isCjs ? __dirname : path.dirname(fileURLToPath(import.meta.url));
+    const staticFilesPath = path.join(currentDirectory, relativePath);
     const router = Router();
     // This only works once the app is built: src/ --> dist/esm/
     // This file: dist/esm/routes/
     // UI bundle: dist/ui/
     // For development, the UI is served separately.
     router.use(express.static(staticFilesPath));
-    router.get('*', (_req, res) => {
-        // Serve the index.html file for all routes
+    router.use((_req, res) => {
         res.sendFile(path.join(staticFilesPath, 'index.html'));
     });
     return router;

package/dist/esm/tlm-util/utilController.js

@@ -47,24 +47,18 @@ export const specLoader = (_req, res, oasTlmConfig) => {
 export const heapStats = (req, res) => {
     const heapStats = v8.getHeapStatistics();
     const roundedHeapStats = Object.getOwnPropertyNames(heapStats).reduce(function (map, stat) {
-        //@ts-expect-error yes
         map[stat] = Math.round((heapStats[stat] / 1024 / 1024) * 1000) / 1000;
         return map;
     }, {});
-    // @ts-expect-error yes
     roundedHeapStats['units'] = 'MB';
     res.send(roundedHeapStats);
 };
 const isCjs = typeof __filename !== "undefined" && typeof __dirname !== "undefined";
-const __filenameUniversal = isCjs
-    ? __filename
-    : fileURLToPath(import.meta.url);
-const __dirnameUniversal = isCjs
-    ? __dirname
-    : path.dirname(__filenameUniversal);
+// @ts-ignore -- import.meta no existe en el build CJS
+const currentDirectory = isCjs ? __dirname : path.dirname(fileURLToPath(import.meta.url));
 export const getOasTelemetrySpec = (_req, res) => {
     try {
-        const specPath = path.join(__dirnameUniversal, '../docs/openapi.yaml');
+        const specPath = path.join(currentDirectory, '../docs/openapi.yaml');
         const data = readFileSync(specPath, { encoding: 'utf8', flag: 'r' });
         let json = data;
         json = JSON.stringify(yaml.load(data), null, 2);

package/dist/esm/tlm-util/utilRoutes.js

@@ -27,8 +27,8 @@ export const getUtilsRoutes = (oasTlmConfig) => {
         res.send({ message: 'Started generating mock logs' });
     });
     // This route is NOT ignored by the spanExporter
-    router.get('/generate-wait/:seconds?', async (req, res) => {
-        const seconds = parseInt(req.params.seconds ?? "1", 10);
+    router.get('/generate-wait', async (req, res) => {
+        const seconds = parseInt(req.query.seconds ?? "1", 10);
         const waitTime = isNaN(seconds) ? 1 : seconds;
         await new Promise(resolve => setTimeout(resolve, waitTime * 1000));
         res.send({ waited: waitTime });

package/dist/types/config/bootConfig.d.ts

@@ -3,4 +3,7 @@ export declare const bootEnvVariables: {
     OASTLM_BOOT_MODULE_DISABLED: boolean;
     OASTLM_BOOT_LOG_LEVEL: string;
     OASTLM_BOOT_SERVICE_NAME: string;
+    OASTLM_BOOT_BASE_URL: string;
+    OASTLM_BOOT_AUTOINSTRUMENTATIONS_NODE_DISABLED: boolean;
+    OASTLM_BOOT_AUTOINSTRUMENTATIONS_LOGS_DISABLED: boolean;
 };