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

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

@@ -1,70 +1,64 @@
 import { inMemoryDbMetricExporter } from '../telemetry/telemetryRegistry.js';
-import { convertRegexRecursively } from '../utils/regexUtils.js';
-export const listMetrics = async (req, res) => {
+/**
+ * Parse NDJSON import data
+ * Each line must be a valid JSON object
+ * @param body - Request body (raw string)
+ * @returns Array of metric objects
+ */
+function parseImportData(body) {
+    if (typeof body !== 'string') {
+        throw new Error('Import must be NDJSON format (plain text with one JSON object per line)');
+    }
+    const lines = body.split('\n').filter((line) => line.trim());
+    return lines.map((line, index) => {
+        try {
+            return JSON.parse(line);
+        }
+        catch {
+            console.error(`Failed to parse NDJSON line ${index + 1}: ${line}`);
+            throw new Error(`Invalid JSON on line ${index + 1}`);
+        }
+    });
+}
+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' });
-    }
-};
-export const findMetrics = (req, res) => {
-    const body = req.body;
-    const query = body?.query ? body.query : {};
-    let processedQuery;
-    try {
-        processedQuery = convertRegexRecursively(query);
+        res.status(500).send({ error: 'Failed to get metrics stats' });
     }
-    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;
+        }
         let message = '';
         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);
-            });
+        // Store samples
+        if (format === 'otel')
+            inMemoryDbMetricExporter.insertOtel(scopeMetricsData);
+        else
+            inMemoryDbMetricExporter.insertRaw(scopeMetricsData);
+        message += `Inserted ${scopeMetricsData.length} scopeMetrics (format: ${format}).`;
+        res.send({
+            message,
+            scopeMetricsCount: scopeMetricsData.length,
+            format
         });
-        message += `Inserted ${cleanedMetrics.length} metrics.`;
-        res.send({ message, InsertedMetricsCount: cleanedMetrics.length });
     }
     catch (err) {
         console.error(err);
@@ -84,7 +78,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 +90,132 @@ 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' });
+    }
+};
+/**
+ * Check data consistency between rawDataDB and queried data
+ * Compares raw exports with findMetrics(format=otel) without filters
+ */
+export const checkMetricsConsistency = async (req, res) => {
+    try {
+        // Get raw exported data
+        const rawData = inMemoryDbMetricExporter.rawDataDB;
+        // Query all data with OTEL format
+        const response = inMemoryDbMetricExporter.find({
+            format: 'otel'
+        });
+        const queriedData = response.results;
+        // Compare counts
+        const statusCheck = rawData.length === queriedData.length;
+        res.json({
+            statusCheck,
+            raw: rawData,
+            queried: queriedData
+        });
+    }
+    catch (err) {
+        console.error(err);
+        res.status(500).json({ error: 'Failed to check metrics consistency' });
+    }
+};
+export const exportMetrics = (req, res) => {
+    try {
+        const ndjsonData = inMemoryDbMetricExporter.exportToNDJSON();
+        const timestamp = new Date().toISOString().slice(0, 19).replace(/[-T:]/g, '');
+        res.setHeader('Content-Type', 'application/x-ndjson');
+        res.setHeader('Content-Disposition', `attachment; filename="metrics-${timestamp}.ndjson"`);
+        res.setHeader('Transfer-Encoding', 'chunked');
+        res.write(ndjsonData);
+        res.end();
+    }
+    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 format = (req.query.format || 'raw');
+    try {
+        const ndjsonContent = req.body;
+        // Check if this is an exported NDJSON with headers (from our export function)
+        const firstLine = ndjsonContent.split('\n')[0];
+        let isExportedFormat = false;
+        try {
+            const firstObj = JSON.parse(firstLine);
+            isExportedFormat = firstObj.type === 'header';
+        }
+        catch {
+            // Not a valid JSON line, continue with normal parsing
+        }
+        let message = '';
+        if (resetData) {
+            inMemoryDbMetricExporter.reset();
+            message += 'Metrics Database reset. ';
+        }
+        // If it's an exported format with headers/metadata, use direct NDJSON import
+        if (isExportedFormat) {
+            inMemoryDbMetricExporter.importFromNDJSON(ndjsonContent);
+            message += `Imported metrics from exported NDJSON format.`;
+            res.send({ message, format: 'exported-ndjson' });
+        }
+        else {
+            // Otherwise parse as raw metrics (queryresults or OTEL format)
+            const metricsArray = parseImportData(ndjsonContent);
+            if (metricsArray.length === 0) {
+                res.status(400).send({ error: 'No valid metrics found in import data' });
+                return;
+            }
+            // Use the same insert logic as insertMetricsToDb, respecting raw vs otel format
+            if (format === 'otel') {
+                inMemoryDbMetricExporter.insertOtel(metricsArray);
+            }
+            else {
+                inMemoryDbMetricExporter.insertRaw(metricsArray);
+            }
+            message += `Imported ${metricsArray.length} metrics (format: ${format}).`;
+            res.send({ message, ImportedMetricsCount: metricsArray.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 { Router, text } from 'express';
+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,15 @@ 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);
+    // Use text middleware for import to handle NDJSON format
+    router.post('/import', text({ type: 'application/x-ndjson', limit: '500mb' }), 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-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,5 +1,26 @@
 import { inMemoryDbSpanExporter } from '../telemetry/telemetryRegistry.js';
 import { convertRegexRecursively } from '../utils/regexUtils.js';
+/**
+ * Parse import data from NDJSON or JSON format
+ * @param contentType - Content-Type header
+ * @param body - Request body (string for NDJSON, object for JSON)
+ * @returns Array of span objects
+ */
+function parseImportData(body) {
+    if (typeof body !== 'string') {
+        throw new Error('Import must be NDJSON format (plain text with one JSON object per line)');
+    }
+    const lines = body.split('\n').filter((line) => line.trim());
+    return lines.map((line, index) => {
+        try {
+            return JSON.parse(line);
+        }
+        catch {
+            console.error(`Failed to parse NDJSON line ${index + 1}: ${line}`);
+            throw new Error(`Invalid JSON on line ${index + 1}`);
+        }
+    });
+}
 export const startTraces = (req, res) => {
     inMemoryDbSpanExporter.enable();
     res.send('Traces started');
@@ -26,37 +47,45 @@ 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
     });
@@ -83,8 +112,43 @@ 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';
+    try {
+        // Parse NDJSON format
+        const spans = parseImportData(req.body);
+        if (spans.length === 0) {
+            res.status(400).send({ error: 'No valid traces found in import data' });
+            return;
+        }
+        const cleanedTraces = spans.map((trace) => {
+            const { _id, ...rest } = trace; // Remove _id if it exists
+            return rest;
+        });
+        let message = '';
+        if (resetData) {
+            inMemoryDbSpanExporter.reset();
+            message += 'Traces Database reset. ';
+        }
+        await new Promise((resolve, reject) => {
+            inMemoryDbSpanExporter.insert(cleanedTraces, (err, newDocs) => {
+                if (err) {
+                    console.error('Error importing traces:', err);
+                    return reject(err);
+                }
+                resolve(newDocs);
+            });
+        });
+        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;
@@ -96,3 +160,25 @@ 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 timestamp = new Date().toISOString().slice(0, 19).replace(/[-T:]/g, '');
+        res.setHeader('Content-Type', 'application/x-ndjson');
+        res.setHeader('Content-Disposition', `attachment; filename="traces-${timestamp}.ndjson"`);
+        res.setHeader('Transfer-Encoding', 'chunked');
+        // Stream as NDJSON (one JSON object per line)
+        docs.forEach(doc => {
+            res.write(JSON.stringify(doc) + '\n');
+        });
+        res.end();
+    }
+    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 { Router, text } from 'express';
+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,9 @@ export const getTraceRoutes = () => {
     router.post('/stop', stopTraces);
     router.get('/status', statusTraces);
     router.post('/reset', resetTraces);
+    router.get('/export', exportTraces);
+    // Use text middleware for import to handle NDJSON format
+    router.post('/import', text({ type: 'application/x-ndjson', limit: '500mb' }), importTraces);
     router.get('/', listTraces);
     router.post('/', insertTracesToDb);
     router.post('/find', findTraces);

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,8 @@ 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;
+    OASTLM_BOOT_STORAGE_PATH: string;
 };