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

package/.env.example

@@ -0,0 +1,26 @@
+# All environment variables are OPTIONAL, defaults are provided below
+
+
+# DEVELOPMENT ----------------------------------------------------------
+# This is JUST for development purposes, to test the react app
+# ----------------------------------------------------------------------
+
+# production, development
+OASTLM_ENV=production
+
+
+# PRODUCTION -----------------------------------------------------------
+# This variables can be configured in the .env file of the project importing our library
+# ----------------------------------------------------------------------
+
+# Disable the module, no Telemetry collected, empty middleware exported
+OASTLM_MODULE_DISABLED=false
+
+OASTLM_AI_OPENAI_API_KEY=
+OASTLM_AI_OPENAI_MODEL_NAME=gpt-4o-mini
+
+# Used in OASTLM logger
+OASTLM_SERVICE_NAME=OAS-TLM
+# LEVELS: DEBUG, INFO, WARNING, ERROR, NONE
+# Note: "NONE" will disable all OASTLM logging
+OASTLM_LOG_LEVEL=INFO

package/NOTICE

@@ -0,0 +1,8 @@
+This software includes code derived from the OpenTelemetry JavaScript SDK
+(https://github.com/open-telemetry/opentelemetry-js).
+
+Some components, such as custom exporters, are based on the structure and patterns
+defined by OpenTelemetry, with modifications and adaptations specific to this project.
+
+Original code licensed under the Apache License, Version 2.0.  
+Copyright © The OpenTelemetry Authors.

package/README.md

@@ -10,6 +10,16 @@ Overall, **OAS Telemetry** will serve as a valuable tool for developers looking
 
 The package now supports both **ES Module (ESM)** and **CommonJS (CJS)** formats, making it compatible with a wide range of applications. The ESM build targets the **ES2020** standard. Furthermore, **OAS Telemetry** provides a range of plugins to extend its functionality. See the [Telemetry Plugins](#telemetry-plugins) section for more information.
 
+> ⚠️ **Warning: Early Development Notice**
+>
+> **OAS Telemetry** is a functional and working package, but it is currently at version 0 and remains under active development. Features, APIs, and behavior are subject to change at any time. Please review the following current status before use:
+>
+> - **UI:** Migration to React is in progress. Most views are placeholders except for the AI agent, which is fully functional and can answer questions about metrics, traces, and logs.
+> - **Traces:** Semi-stable. Currently supports HTTP instrumentation; future updates will add propagators.
+> - **Logs:** Semi-stable. Supports fast search by message content and Mongo-like search (similar to traces).
+> - **Metrics:** Not stable. Currently uses OpenTelemetry host metrics. This area is subject to significant change to improve memory usage and data handling.
+> - **Configuration:** Not stable. All configuration options will be available as parameters at initialization and via environment variables (see the `.env.example` file). The configuration system is under active development and will change significantly in future releases.
+
 ## Usage
 
 This section provides an overview of how to install and integrate **OAS Telemetry** into your EXISTING **Express.js** application. If you want to create a new example express application with **OAS Telemetry** integrated, refer to the [Full Examples](#full-examples) section at the end of this document.
@@ -20,6 +30,8 @@ First, install the package using npm:
 npm install @oas-tools/oas-telemetry
 ```
 
+Then add the .env file to your project root directory. This file contains the environment variables used by the telemetry middleware. You can find an example of the .env file in the [`.env.example`](.env.example) file in the root of the repository. The `.env` file is optional, but it is needed for the ai chat.
+
 You can integrate the middleware into your Express application. The `spec` option is the OpenAPI Specification (OAS) content in JSON or YAML format. While this configuration is optional, it is recommended for the UI to function correctly.
 
 ### Using ES Modules (ESM)
@@ -32,6 +44,7 @@ import oasTelemetry from '@oas-tools/oas-telemetry';
 import { readFileSync } from 'fs';
 
 // ...rest of your code here creating an express app
+// NOTE: Do not add express.json() before oasTelemetry, or set its limit to at least "10mb" to avoid issues with large files.
 
 app.use(oasTelemetry({
     spec: readFileSync('./spec/oas.yaml', { encoding: 'utf8', flag: 'r' })
@@ -48,6 +61,7 @@ const oasTelemetry = require('@oas-tools/oas-telemetry');
 const { readFileSync } = require('fs');
 
 // ...rest of your code here creating an express app
+// NOTE: Do not add express.json() before oasTelemetry, or set its limit to at least "10mb" to avoid issues with large files.
 
 app.use(oasTelemetry({
     spec: readFileSync('./spec/oas.yaml', { encoding: 'utf8', flag: 'r' })
@@ -81,9 +95,64 @@ app.use(oasTelemetry(customTelemetryConfig));
 
 You can access the telemetry UI in the endpoint `/telemetry` (or `/custom-telemetry` if you set the `baseURL` option). This UI provides a user-friendly interface to interact with the telemetry data collected by the middleware.
 
+## Rest API Endpoints Overview
+
+### Authentication Endpoints
+
+- `POST /login`: Log in to the system.
+- `GET /logout`: Log out of the system.
+- `GET /check`: Check authentication status.
+
+### Metrics Endpoints
+
+- `GET /metrics`: List all metrics.
+- `POST /metrics`: Insert metrics into the database.
+- `POST /metrics/find`: Search metrics.
+- `GET /metrics/start`: Start metrics data collection.
+- `GET /metrics/stop`: Stop metrics data collection.
+- `GET /metrics/status`: Get metrics status.
+- `GET /metrics/reset`: Reset metrics data.
+
+### Logs Endpoints
+
+- `GET /logs`: List all logs.
+- `POST /logs`: Insert logs into the database.
+- `POST /logs/find`: Search logs.
+- `GET /logs/start`: Start logs data collection.
+- `GET /logs/stop`: Stop logs data collection.
+- `GET /logs/status`: Get logs status.
+- `GET /logs/reset`: Reset logs data.
+
+### Traces Endpoints
+
+- `GET /traces`: List all traces.
+- `POST /traces`: Insert traces into the database.
+- `POST /traces/find`: Search traces.
+- `GET /traces/start`: Start traces data collection.
+- `GET /traces/stop`: Stop traces data collection.
+- `GET /traces/status`: Get traces status.
+- `GET /traces/reset`: Reset traces data.
+
+### AI Endpoints
+
+- `POST /ai/chat`: Interact with the AI agent.
+- `POST /ai/microservices`: Configure known microservices.
+- `GET /ai/microservices`: Retrieve the list of known microservices.
+
+### UI Endpoints
+
+- `GET *`: Serve the telemetry UI.
+
+### Utility Endpoints
+
+- `GET /utils/spec`: Load the OpenAPI specification.
+- `GET /utils/heapStats`: Show v8 heap statistics.
+- `GET /utils/generateLog`: Generate a log message.
+- `GET /utils/wait/:seconds?`: Wait for a specified number of seconds.
+
 ## Metrics Development (Temporary)
 
-This feature is currently in development. The following endpoints are available under <baseURL>/metrics (e.g., /telemetry/metrics):
+This feature is currently in development. The following endpoints are available under \<baseURL>/metrics (e.g., /telemetry/metrics):
 
 - GET /
 - POST /find
@@ -91,6 +160,9 @@ This feature is currently in development. The following endpoints are available
 
 Expect an array of metrics objects. Each object includes data like a timestamp, cpuUsageData, processCpuUsageData, memoryData, and processMemoryData. Example snippet for one CPU core (followed by others in the array):
 
+> **Warning**  
+> Stored metrics data now uses `@opentelemetry/host-metrics`, which is still in development. The data structure may change in future releases.
+
 ```json
 {
     "timestamp": 1741717005911,
@@ -128,20 +200,6 @@ Expect an array of metrics objects. Each object includes data like a timestamp,
 
 The shape of these objects may change as development continues.
 
-## API Telemetry Endpoints
-
-OAS Telemetry middleware adds the following endpoints to your Express application:
-
-- /telemetry/start: Start telemetry data collection.
-- /telemetry/stop: Stop telemetry data collection.
-- /telemetry/status: Get status of telemetry.
-- /telemetry/reset: Reset telemetry data.
-- /telemetry/list: List all telemetry data.
-- /telemetry/find (POST): Search telemetry data.
-- /telemetry/heapStats: Shows v8 heapStats.
-- /telemetry/plugins: List all plugins.
-- /telemetry/plugins (POST): Add a plugin.
-
 ## Telemetry Plugins
 
 OAS Telemetry supports a range of plugins to extend its functionality, allowing developers to tailor telemetry data collection, alerting, and reporting to meet specific requirements. Plugins enable additional features, such as integration with alerting systems, custom data exporters, and data visualization tools.
@@ -157,13 +215,13 @@ This flexibility makes it easy to incorporate a wide variety of plugins in your
 
 ## Accessing Telemetry Data
 
-Using OAS Telemetry, you can access telemetry data through the UI, the `/telemetry/list` endpoint, or the `/telemetry/find` endpoint with a POST request using a MongoDB search syntax.
+Using OAS Telemetry, you can access telemetry data through the UI (WIP), the `/telemetry/traces` endpoint, or the `/telemetry/traces/find` endpoint with a POST request using a MongoDB search syntax.
 
 Note: if authentication is enabled, you must provide the correct credentials to access the telemetry data.
 
 ### Simple Search Example
 
-To perform a simple search, send a POST request to the `/telemetry/find` endpoint with the following JSON payload:
+To perform a simple search, send a POST request to the `/telemetry/traces/find` endpoint with the following JSON payload:
 
 ```json
 {
@@ -180,7 +238,7 @@ To perform a simple search, send a POST request to the `/telemetry/find` endpoin
 
 ### Complex Search Example
 
-For more complex searches using regex, additional parsing on the server and extra attributes in the POST request are required. Send a POST request to the `/telemetry/find` endpoint with the following JSON payload:
+For more complex searches using regex, additional parsing on the server and extra attributes in the POST request are required. Send a POST request to the `/telemetry/traces/find` endpoint with the following JSON payload:
 
 ```json
 {

package/dist/cjs/exporters/InMemoryDBMetricsExporter.cjs

@@ -16,8 +16,8 @@ class InMemoryDBMetricsExporter {
   export(metrics, resultCallback) {
     try {
       if (!this._stopped) {
-        // metrics = metrics?.scopeMetrics;
-        const cleanMetrics = (0, _circular.applyNesting)(metrics);
+        const scopeMetrics = metrics?.scopeMetrics;
+        const cleanMetrics = (0, _circular.applyNesting)(scopeMetrics);
         this._metrics.insert(cleanMetrics, (err, _newDoc) => {
           if (err) {
             console.error('Insertion Error:', err);
@@ -62,5 +62,13 @@ class InMemoryDBMetricsExporter {
   getFinishedMetrics() {
     return this._metrics.getAllData();
   }
+  /**
+   * Inserts metrics into the in-memory database.
+   * @param metrics - The metrics to insert.
+   * @param callback - The callback to execute after insertion.
+   */
+  insert(metrics, callback) {
+    this._metrics.insert(metrics, callback);
+  }
 }
 exports.InMemoryDBMetricsExporter = InMemoryDBMetricsExporter;

package/dist/cjs/exporters/InMemoryDbExporter.cjs

@@ -8,6 +8,7 @@ var _core = require("@opentelemetry/core");
 var _nedb = _interopRequireDefault(require("@seald-io/nedb"));
 var _logger = _interopRequireDefault(require("../utils/logger.cjs"));
 var _circular = require("../utils/circular.cjs");
+var _config = require("../config.cjs");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 //import in memory database
 
@@ -24,7 +25,13 @@ class InMemoryExporter {
         // Prepare spans to be inserted into the in-memory database (remove circular references and convert to nested objects)
         const cleanSpans = readableSpans.map(nestedSpan => (0, _circular.removeCircularRefs)(nestedSpan)) // to avoid JSON parsing error
         .map(span => (0, _circular.applyNesting)(span)) // to avoid dot notation in keys (neDB does not support dot notation in keys)
-        .filter(span => !span?.attributes?.http?.target?.includes("/telemetry")); // to avoid telemetry spans
+        .filter(span => {
+          const target = span?.attributes?.http?.target; // Exclude spans where target includes 'telemetry' but NOT 'telemetry/utils'
+          if (target && target.includes(_config.globalOasTlmConfig.baseURL)) {
+            return target.includes(_config.globalOasTlmConfig.baseURL + '/utils');
+          }
+          return true;
+        });
         // Insert spans into the in-memory database
         this._spans.insert(cleanSpans, (err, _newDoc) => {
           // p = {name, plugin
@@ -83,5 +90,13 @@ class InMemoryExporter {
   getFinishedSpans() {
     return this._spans.getAllData();
   }
+  /**
+   * Inserts spans into the in-memory database.
+   * @param spans - The spans to insert.
+   * @param callback - The callback to execute after insertion.
+   */
+  insert(spans, callback) {
+    this._spans.insert(spans, callback);
+  }
 }
 exports.InMemoryExporter = InMemoryExporter;

package/dist/cjs/exporters/InMemoryLogRecordExporter.cjs

@@ -17,6 +17,7 @@ class InMemoryLogRecordExporter {
       storeFields: ['_id'],
       idField: '_id'
     });
+    this._stopped = false;
   }
   /*
   * SUPER WARNING:
@@ -30,6 +31,12 @@ class InMemoryLogRecordExporter {
    * @param resultCallback
    */
   export(logs, resultCallback) {
+    if (this._stopped) {
+      resultCallback({
+        code: _core.ExportResultCode.SUCCESS
+      });
+      return;
+    }
     const logsToInsert = logs.map(logRecord => {
       // Remove circular references first, then apply nesting, then export info
       const formattedLog = this._formatLogRecord(logRecord);
@@ -37,20 +44,7 @@ class InMemoryLogRecordExporter {
       const nestedLog = (0, _circular.applyNesting)(cleanedLog);
       return nestedLog;
     });
-    this._db.insert(logsToInsert, (err, newDocs) => {
-      if (err) {
-        console.dir(err);
-        resultCallback({
-          code: _core.ExportResultCode.FAILED
-        });
-        return;
-      }
-      // console.dir(newDocs, { depth: 3 });
-      newDocs.forEach(doc => this._miniSearch.add(doc));
-      resultCallback({
-        code: _core.ExportResultCode.SUCCESS
-      });
-    });
+    this._insertLogs(logsToInsert, resultCallback);
   }
   reset() {
     this._db = new _nedb.default();
@@ -81,7 +75,32 @@ class InMemoryLogRecordExporter {
     }
     this._db.find(query, callback);
   }
-  getFinishedSpans() {
+  insert(data, callback) {
+    this._insertLogs(data, result => {
+      if (result.code === _core.ExportResultCode.SUCCESS) {
+        this._db.find({}, (err, docs) => {
+          if (err) {
+            console.dir(err);
+            callback(err, []);
+            return;
+          }
+          callback(null, docs);
+        });
+      } else {
+        callback(new Error('Failed to insert logs'), []);
+      }
+    });
+  }
+  start() {
+    this._stopped = false;
+  }
+  stop() {
+    this._stopped = true;
+  }
+  isRunning() {
+    return !this._stopped;
+  }
+  getFinishedLogs() {
     return this._db.getAllData();
   }
   /**
@@ -106,5 +125,22 @@ class InMemoryLogRecordExporter {
       attributes: logRecord.attributes
     };
   }
+  _insertLogs(logsToInsert, resultCallback) {
+    this._db.insert(logsToInsert, (err, newDocs) => {
+      if (err) {
+        console.dir(err);
+        resultCallback({
+          code: _core.ExportResultCode.FAILED
+        });
+        return;
+      }
+      // console.dir(newDocs, { depth: 3 });
+      newDocs.forEach(doc => this._miniSearch.add(doc));
+      resultCallback({
+        code: _core.ExportResultCode.SUCCESS
+      });
+    });
+    return;
+  }
 }
 exports.InMemoryLogRecordExporter = InMemoryLogRecordExporter;

package/dist/cjs/tlm-log/logController.cjs

@@ -3,11 +3,14 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.resetLogs = exports.listLogs = exports.findLogs = void 0;
+exports.stopLogs = exports.statusLogs = exports.startLogs = exports.resetLogs = exports.listLogs = exports.insertLogsToDb = exports.findLogs = void 0;
 var _config = require("../config.cjs");
+const _excluded = ["_id"];
+function _objectWithoutProperties(e, t) { if (null == e) return {}; var o, r, i = _objectWithoutPropertiesLoose(e, t); if (Object.getOwnPropertySymbols) { var n = Object.getOwnPropertySymbols(e); for (r = 0; r < n.length; r++) o = n[r], -1 === t.indexOf(o) && {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]); } return i; }
+function _objectWithoutPropertiesLoose(r, e) { if (null == r) return {}; var t = {}; for (var n in r) if ({}.hasOwnProperty.call(r, n)) { if (-1 !== e.indexOf(n)) continue; t[n] = r[n]; } return t; }
 const listLogs = async (req, res) => {
   try {
-    const logs = _config.globalOasTlmConfig.logExporter.getFinishedSpans();
+    const logs = _config.globalOasTlmConfig.logExporter.getFinishedLogs();
     res.send({
       logsCount: logs.length,
       logs: logs
@@ -52,4 +55,67 @@ const resetLogs = (req, res) => {
   _config.globalOasTlmConfig.logExporter.reset();
   res.send('Logs reset');
 };
-exports.resetLogs = resetLogs;
+exports.resetLogs = resetLogs;
+const insertLogsToDb = async (req, res) => {
+  const jsonContent = req.body.logs;
+  const resetData = req.query.reset === 'true';
+  if (!Array.isArray(jsonContent)) {
+    res.status(400).send({
+      error: 'Invalid data format. Expected an array of JSON objects.'
+    });
+    return;
+  }
+  const cleanedLogs = jsonContent.map(log => {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const {
+        _id
+      } = log,
+      rest = _objectWithoutProperties(log, _excluded); // Remove _id if it exists
+    return rest; // Return the cleaned log object
+  });
+  try {
+    let message = '';
+    if (resetData) {
+      _config.globalOasTlmConfig.logExporter.reset();
+      message += 'Logs Database reset. ';
+    }
+    await new Promise((resolve, reject) => {
+      _config.globalOasTlmConfig.logExporter.insert(cleanedLogs, (err, newDocs) => {
+        if (err) {
+          console.error('Error inserting logs:', err);
+          return reject(err);
+        }
+        resolve(newDocs);
+      });
+    });
+    message += `Inserted ${cleanedLogs.length} logs.`;
+    res.send({
+      message,
+      InsertedLogsCount: cleanedLogs.length
+    });
+  } catch (err) {
+    console.error(err);
+    res.status(500).send({
+      error: 'Failed to reset and insert data',
+      details: err.message
+    });
+  }
+};
+exports.insertLogsToDb = insertLogsToDb;
+const startLogs = (req, res) => {
+  _config.globalOasTlmConfig.logExporter.start();
+  res.send('Log collection started');
+};
+exports.startLogs = startLogs;
+const stopLogs = (req, res) => {
+  _config.globalOasTlmConfig.logExporter.stop();
+  res.send('Log collection stopped');
+};
+exports.stopLogs = stopLogs;
+const statusLogs = (req, res) => {
+  const isRunning = _config.globalOasTlmConfig.logExporter.isRunning() || false;
+  res.send({
+    active: isRunning
+  });
+};
+exports.statusLogs = statusLogs;

package/dist/cjs/tlm-log/logRoutes.cjs

@@ -7,7 +7,12 @@ exports.logRoutes = exports.default = void 0;
 var _express = require("express");
 var _logController = require("./logController.cjs");
 const logRoutes = exports.logRoutes = (0, _express.Router)();
+// Logs Control
+logRoutes.get('/start', _logController.startLogs);
+logRoutes.get('/stop', _logController.stopLogs);
+logRoutes.get('/status', _logController.statusLogs);
+logRoutes.get('/reset', _logController.resetLogs);
 logRoutes.get('/', _logController.listLogs);
+logRoutes.post('/', _logController.insertLogsToDb);
 logRoutes.post('/find', _logController.findLogs);
-logRoutes.get('/reset', _logController.resetLogs);
 var _default = exports.default = logRoutes;

package/dist/cjs/tlm-metric/metricsController.cjs

@@ -3,11 +3,14 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.resetMetrics = exports.listMetrics = exports.findMetrics = void 0;
+exports.stopMetrics = exports.statusMetrics = exports.startMetrics = exports.resetMetrics = exports.listMetrics = exports.insertMetricsToDb = exports.findMetrics = void 0;
 var _config = require("../config.cjs");
+const _excluded = ["_id"];
+function _objectWithoutProperties(e, t) { if (null == e) return {}; var o, r, i = _objectWithoutPropertiesLoose(e, t); if (Object.getOwnPropertySymbols) { var n = Object.getOwnPropertySymbols(e); for (r = 0; r < n.length; r++) o = n[r], -1 === t.indexOf(o) && {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]); } return i; }
+function _objectWithoutPropertiesLoose(r, e) { if (null == r) return {}; var t = {}; for (var n in r) if ({}.hasOwnProperty.call(r, n)) { if (-1 !== e.indexOf(n)) continue; t[n] = r[n]; } return t; }
 const listMetrics = async (req, res) => {
   try {
-    const metrics = await _config.globalOasTlmConfig.metricsExporter.getFinishedMetrics();
+    const metrics = _config.globalOasTlmConfig.metricsExporter.getFinishedMetrics();
     res.send({
       metricsCount: metrics.length,
       metrics: metrics
@@ -45,4 +48,67 @@ const resetMetrics = (req, res) => {
   _config.globalOasTlmConfig.metricsExporter.reset();
   res.send('Metrics reset');
 };
-exports.resetMetrics = resetMetrics;
+exports.resetMetrics = resetMetrics;
+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. Expected an array of JSON objects.'
+    });
+    return;
+  }
+  const cleanedMetrics = jsonContent.map(metric => {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const {
+        _id
+      } = metric,
+      rest = _objectWithoutProperties(metric, _excluded); // Remove _id if it exists
+    return rest; // Return the cleaned metric object
+  });
+  try {
+    let message = '';
+    if (resetData) {
+      _config.globalOasTlmConfig.metricsExporter.reset();
+      message += 'Metrics Database reset. ';
+    }
+    await new Promise((resolve, reject) => {
+      _config.globalOasTlmConfig.metricsExporter.insert(cleanedMetrics, (err, newDocs) => {
+        if (err) {
+          console.error('Error inserting metrics:', err);
+          return reject(err);
+        }
+        resolve(newDocs);
+      });
+    });
+    message += `Inserted ${cleanedMetrics.length} metrics.`;
+    res.send({
+      message,
+      InsertedMetricsCount: cleanedMetrics.length
+    });
+  } catch (err) {
+    console.error(err);
+    res.status(500).send({
+      error: 'Failed to reset and insert data',
+      details: err.message
+    });
+  }
+};
+exports.insertMetricsToDb = insertMetricsToDb;
+const startMetrics = (req, res) => {
+  _config.globalOasTlmConfig.metricsExporter.start();
+  res.send('Metrics collection started');
+};
+exports.startMetrics = startMetrics;
+const stopMetrics = (req, res) => {
+  _config.globalOasTlmConfig.metricsExporter.stop();
+  res.send('Metrics collection stopped');
+};
+exports.stopMetrics = stopMetrics;
+const statusMetrics = (req, res) => {
+  const isRunning = _config.globalOasTlmConfig.metricsExporter.isRunning() || false;
+  res.send({
+    active: isRunning
+  });
+};
+exports.statusMetrics = statusMetrics;

package/dist/cjs/tlm-metric/metricsRoutes.cjs

@@ -9,6 +9,10 @@ var _metricsController = require("./metricsController.cjs");
 const metricsRoutes = exports.metricsRoutes = (0, _express.Router)();
 // Metrics Control
 metricsRoutes.get('/', _metricsController.listMetrics);
+metricsRoutes.post('/', _metricsController.insertMetricsToDb);
 metricsRoutes.post('/find', _metricsController.findMetrics);
 metricsRoutes.get('/reset', _metricsController.resetMetrics);
+metricsRoutes.get('/start', _metricsController.startMetrics);
+metricsRoutes.get('/stop', _metricsController.stopMetrics);
+metricsRoutes.get('/status', _metricsController.statusMetrics);
 var _default = exports.default = metricsRoutes;

package/dist/cjs/tlm-trace/traceController.cjs

@@ -3,8 +3,11 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.stopTelemetry = exports.statusTelemetry = exports.startTelemetry = exports.resetTelemetry = exports.listTelemetry = exports.findTelemetry = void 0;
+exports.stopTelemetry = exports.statusTelemetry = exports.startTelemetry = exports.resetTelemetry = exports.listTelemetry = exports.insertTracesToDb = exports.findTelemetry = void 0;
 var _config = require("../config.cjs");
+const _excluded = ["_id"];
+function _objectWithoutProperties(e, t) { if (null == e) return {}; var o, r, i = _objectWithoutPropertiesLoose(e, t); if (Object.getOwnPropertySymbols) { var n = Object.getOwnPropertySymbols(e); for (r = 0; r < n.length; r++) o = n[r], -1 === t.indexOf(o) && {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]); } return i; }
+function _objectWithoutPropertiesLoose(r, e) { if (null == r) return {}; var t = {}; for (var n in r) if ({}.hasOwnProperty.call(r, n)) { if (-1 !== e.indexOf(n)) continue; t[n] = r[n]; } return t; }
 const startTelemetry = (req, res) => {
   _config.globalOasTlmConfig.dynamicSpanExporter.exporter.start();
   res.send('Telemetry started');
@@ -78,4 +81,50 @@ const findTelemetry = (req, res) => {
     });
   });
 };
-exports.findTelemetry = findTelemetry;
+exports.findTelemetry = findTelemetry;
+const insertTracesToDb = async (req, res) => {
+  const jsonContent = req.body.spans;
+  const resetData = req.query.reset === 'true';
+  if (!Array.isArray(jsonContent)) {
+    res.status(400).send({
+      error: 'Invalid data format. Expected an array of JSON objects.'
+    });
+    return;
+  }
+  const cleanedTraces = jsonContent.map(trace => {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const {
+        _id
+      } = trace,
+      rest = _objectWithoutProperties(trace, _excluded); // Remove _id if it exists
+    return rest; // Return the cleaned trace object
+  });
+  try {
+    let message = '';
+    if (resetData) {
+      _config.globalOasTlmConfig.dynamicSpanExporter.exporter.reset();
+      message += 'Traces Database reset. ';
+    }
+    await new Promise((resolve, reject) => {
+      _config.globalOasTlmConfig.dynamicSpanExporter.exporter.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
+    });
+  } catch (err) {
+    console.error(err);
+    res.status(500).send({
+      error: 'Failed to reset and insert data',
+      details: err.message
+    });
+  }
+};
+exports.insertTracesToDb = insertTracesToDb;

package/dist/cjs/tlm-trace/traceRoutes.cjs

@@ -8,6 +8,7 @@ var _express = require("express");
 var _traceController = require("./traceController.cjs");
 const traceRoutes = exports.traceRoutes = (0, _express.Router)();
 traceRoutes.get('/', _traceController.listTelemetry);
+traceRoutes.post('/', _traceController.insertTracesToDb);
 traceRoutes.post('/find', _traceController.findTelemetry);
 // Telemetry Control
 traceRoutes.get('/start', _traceController.startTelemetry);

package/dist/cjs/tlm-util/utilRoutes.cjs

@@ -9,4 +9,20 @@ var _utilController = require("./utilController.cjs");
 const utilsRoutes = exports.utilsRoutes = (0, _express.Router)();
 utilsRoutes.get('/spec', _utilController.specLoader);
 utilsRoutes.get('/heapStats', _utilController.heapStats);
+utilsRoutes.get('/generateLog', (req, res) => {
+  const log = req.query.log || 'Default log message';
+  console.log('Generated log:', log);
+  res.send({
+    message: 'Log generated',
+    log: log
+  });
+});
+utilsRoutes.get('/wait/:seconds?', async (req, res) => {
+  const seconds = parseInt(req.params.seconds ?? "1", 10);
+  const waitTime = isNaN(seconds) ? 1 : seconds;
+  await new Promise(resolve => setTimeout(resolve, waitTime * 1000));
+  res.send({
+    waited: waitTime
+  });
+});
 var _default = exports.default = utilsRoutes;

package/dist/cjs/tlmRoutes.cjs

@@ -32,7 +32,9 @@ const configureRoutes = router => {
     if (req.body !== undefined) {
       return next(); // Already parsed, no need to parse again.
     }
-    return (0, _express.json)()(req, res, next);
+    return (0, _express.json)({
+      limit: '10mb'
+    })(req, res, next);
   });
   const allAuthMiddlewares = getWrappedMiddlewares(() => _config.globalOasTlmConfig.authEnabled, [(0, _cookieParser.default)(), _authRoutes.default, _authMiddleware.authMiddleware]);
   const baseURL = _config.globalOasTlmConfig.baseURL;

package/dist/esm/exporters/InMemoryDBMetricsExporter.js

@@ -9,8 +9,8 @@ export class InMemoryDBMetricsExporter {
     export(metrics, resultCallback) {
         try {
             if (!this._stopped) {
-                // metrics = metrics?.scopeMetrics;
-                const cleanMetrics = applyNesting(metrics);
+                const scopeMetrics = metrics?.scopeMetrics;
+                const cleanMetrics = applyNesting(scopeMetrics);
                 this._metrics.insert(cleanMetrics, (err, _newDoc) => {
                     if (err) {
                         console.error('Insertion Error:', err);
@@ -54,4 +54,12 @@ export class InMemoryDBMetricsExporter {
     getFinishedMetrics() {
         return this._metrics.getAllData();
     }
+    /**
+     * Inserts metrics into the in-memory database.
+     * @param metrics - The metrics to insert.
+     * @param callback - The callback to execute after insertion.
+     */
+    insert(metrics, callback) {
+        this._metrics.insert(metrics, callback);
+    }
 }

package/dist/esm/exporters/InMemoryDbExporter.js

@@ -3,6 +3,7 @@ import { ExportResultCode } from '@opentelemetry/core';
 import dataStore from '@seald-io/nedb';
 import logger from '../utils/logger.js';
 import { applyNesting, removeCircularRefs } from '../utils/circular.js';
+import { globalOasTlmConfig } from '../config.js';
 export class InMemoryExporter {
     constructor() {
         // Overrided by dynamic exporter
@@ -18,7 +19,13 @@ export class InMemoryExporter {
                 const cleanSpans = readableSpans
                     .map(nestedSpan => removeCircularRefs(nestedSpan)) // to avoid JSON parsing error
                     .map(span => applyNesting(span)) // to avoid dot notation in keys (neDB does not support dot notation in keys)
-                    .filter(span => !span?.attributes?.http?.target?.includes("/telemetry")); // to avoid telemetry spans
+                    .filter(span => {
+                    const target = span?.attributes?.http?.target; // Exclude spans where target includes 'telemetry' but NOT 'telemetry/utils'
+                    if (target && target.includes(globalOasTlmConfig.baseURL)) {
+                        return target.includes(globalOasTlmConfig.baseURL + '/utils');
+                    }
+                    return true;
+                });
                 // Insert spans into the in-memory database
                 this._spans.insert(cleanSpans, (err, _newDoc) => {
                     // p = {name, plugin
@@ -84,4 +91,12 @@ export class InMemoryExporter {
         return this._spans.getAllData();
     }
     ;
+    /**
+     * Inserts spans into the in-memory database.
+     * @param spans - The spans to insert.
+     * @param callback - The callback to execute after insertion.
+     */
+    insert(spans, callback) {
+        this._spans.insert(spans, callback);
+    }
 }

package/dist/esm/exporters/InMemoryLogRecordExporter.js

@@ -11,6 +11,7 @@ export class InMemoryLogRecordExporter {
             storeFields: ['_id'],
             idField: '_id',
         });
+        this._stopped = false;
     }
     /*
     * SUPER WARNING:
@@ -24,6 +25,10 @@ export class InMemoryLogRecordExporter {
      * @param resultCallback
      */
     export(logs, resultCallback) {
+        if (this._stopped) {
+            resultCallback({ code: ExportResultCode.SUCCESS });
+            return;
+        }
         const logsToInsert = logs.map(logRecord => {
             // Remove circular references first, then apply nesting, then export info
             const formattedLog = this._formatLogRecord(logRecord);
@@ -31,16 +36,7 @@ export class InMemoryLogRecordExporter {
             const nestedLog = applyNesting(cleanedLog);
             return nestedLog;
         });
-        this._db.insert(logsToInsert, (err, newDocs) => {
-            if (err) {
-                console.dir(err);
-                resultCallback({ code: ExportResultCode.FAILED });
-                return;
-            }
-            // console.dir(newDocs, { depth: 3 });
-            newDocs.forEach((doc) => this._miniSearch.add(doc));
-            resultCallback({ code: ExportResultCode.SUCCESS });
-        });
+        this._insertLogs(logsToInsert, resultCallback);
     }
     reset() {
         this._db = new Datastore();
@@ -67,7 +63,33 @@ export class InMemoryLogRecordExporter {
         }
         this._db.find(query, callback);
     }
-    getFinishedSpans() {
+    insert(data, callback) {
+        this._insertLogs(data, (result) => {
+            if (result.code === ExportResultCode.SUCCESS) {
+                this._db.find({}, (err, docs) => {
+                    if (err) {
+                        console.dir(err);
+                        callback(err, []);
+                        return;
+                    }
+                    callback(null, docs);
+                });
+            }
+            else {
+                callback(new Error('Failed to insert logs'), []);
+            }
+        });
+    }
+    start() {
+        this._stopped = false;
+    }
+    stop() {
+        this._stopped = true;
+    }
+    isRunning() {
+        return !this._stopped;
+    }
+    getFinishedLogs() {
         return this._db.getAllData();
     }
     /**
@@ -92,4 +114,17 @@ export class InMemoryLogRecordExporter {
             attributes: logRecord.attributes,
         };
     }
+    _insertLogs(logsToInsert, resultCallback) {
+        this._db.insert(logsToInsert, (err, newDocs) => {
+            if (err) {
+                console.dir(err);
+                resultCallback({ code: ExportResultCode.FAILED });
+                return;
+            }
+            // console.dir(newDocs, { depth: 3 });
+            newDocs.forEach((doc) => this._miniSearch.add(doc));
+            resultCallback({ code: ExportResultCode.SUCCESS });
+        });
+        return;
+    }
 }

package/dist/esm/tlm-log/logController.js

@@ -1,7 +1,7 @@
 import { globalOasTlmConfig } from '../config.js';
 export const listLogs = async (req, res) => {
     try {
-        const logs = globalOasTlmConfig.logExporter.getFinishedSpans();
+        const logs = globalOasTlmConfig.logExporter.getFinishedLogs();
         res.send({ logsCount: logs.length, logs: logs });
     }
     catch (err) {
@@ -34,3 +34,50 @@ export const resetLogs = (req, res) => {
     globalOasTlmConfig.logExporter.reset();
     res.send('Logs reset');
 };
+export const insertLogsToDb = async (req, res) => {
+    const jsonContent = req.body.logs;
+    const resetData = req.query.reset === 'true';
+    if (!Array.isArray(jsonContent)) {
+        res.status(400).send({ error: 'Invalid data format. Expected an array of JSON objects.' });
+        return;
+    }
+    const cleanedLogs = jsonContent.map((log) => {
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const { _id, ...rest } = log; // Remove _id if it exists
+        return rest; // Return the cleaned log object
+    });
+    try {
+        let message = '';
+        if (resetData) {
+            globalOasTlmConfig.logExporter.reset();
+            message += 'Logs Database reset. ';
+        }
+        await new Promise((resolve, reject) => {
+            globalOasTlmConfig.logExporter.insert(cleanedLogs, (err, newDocs) => {
+                if (err) {
+                    console.error('Error inserting logs:', err);
+                    return reject(err);
+                }
+                resolve(newDocs);
+            });
+        });
+        message += `Inserted ${cleanedLogs.length} logs.`;
+        res.send({ message, InsertedLogsCount: cleanedLogs.length });
+    }
+    catch (err) {
+        console.error(err);
+        res.status(500).send({ error: 'Failed to reset and insert data', details: err.message });
+    }
+};
+export const startLogs = (req, res) => {
+    globalOasTlmConfig.logExporter.start();
+    res.send('Log collection started');
+};
+export const stopLogs = (req, res) => {
+    globalOasTlmConfig.logExporter.stop();
+    res.send('Log collection stopped');
+};
+export const statusLogs = (req, res) => {
+    const isRunning = globalOasTlmConfig.logExporter.isRunning() || false;
+    res.send({ active: isRunning });
+};

package/dist/esm/tlm-log/logRoutes.js

@@ -1,7 +1,12 @@
 import { Router } from 'express';
-import { listLogs, findLogs, resetLogs } from './logController.js';
+import { startLogs, stopLogs, statusLogs, resetLogs, listLogs, findLogs, insertLogsToDb } from './logController.js';
 export const logRoutes = Router();
+// Logs Control
+logRoutes.get('/start', startLogs);
+logRoutes.get('/stop', stopLogs);
+logRoutes.get('/status', statusLogs);
+logRoutes.get('/reset', resetLogs);
 logRoutes.get('/', listLogs);
+logRoutes.post('/', insertLogsToDb);
 logRoutes.post('/find', findLogs);
-logRoutes.get('/reset', resetLogs);
 export default logRoutes;

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

@@ -1,7 +1,7 @@
 import { globalOasTlmConfig } from '../config.js';
 export const listMetrics = async (req, res) => {
     try {
-        const metrics = await globalOasTlmConfig.metricsExporter.getFinishedMetrics();
+        const metrics = globalOasTlmConfig.metricsExporter.getFinishedMetrics();
         res.send({ metricsCount: metrics.length, metrics: metrics });
     }
     catch (err) {
@@ -26,3 +26,50 @@ export const resetMetrics = (req, res) => {
     globalOasTlmConfig.metricsExporter.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. Expected an array of JSON objects.' });
+        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 {
+        let message = '';
+        if (resetData) {
+            globalOasTlmConfig.metricsExporter.reset();
+            message += 'Metrics Database reset. ';
+        }
+        await new Promise((resolve, reject) => {
+            globalOasTlmConfig.metricsExporter.insert(cleanedMetrics, (err, newDocs) => {
+                if (err) {
+                    console.error('Error inserting metrics:', err);
+                    return reject(err);
+                }
+                resolve(newDocs);
+            });
+        });
+        message += `Inserted ${cleanedMetrics.length} metrics.`;
+        res.send({ message, InsertedMetricsCount: cleanedMetrics.length });
+    }
+    catch (err) {
+        console.error(err);
+        res.status(500).send({ error: 'Failed to reset and insert data', details: err.message });
+    }
+};
+export const startMetrics = (req, res) => {
+    globalOasTlmConfig.metricsExporter.start();
+    res.send('Metrics collection started');
+};
+export const stopMetrics = (req, res) => {
+    globalOasTlmConfig.metricsExporter.stop();
+    res.send('Metrics collection stopped');
+};
+export const statusMetrics = (req, res) => {
+    const isRunning = globalOasTlmConfig.metricsExporter.isRunning() || false;
+    res.send({ active: isRunning });
+};

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

@@ -1,8 +1,12 @@
 import { Router } from 'express';
-import { listMetrics, findMetrics, resetMetrics } from './metricsController.js';
+import { listMetrics, findMetrics, resetMetrics, insertMetricsToDb, startMetrics, stopMetrics, statusMetrics } from './metricsController.js';
 export const metricsRoutes = Router();
 // Metrics Control
 metricsRoutes.get('/', listMetrics);
+metricsRoutes.post('/', insertMetricsToDb);
 metricsRoutes.post('/find', findMetrics);
 metricsRoutes.get('/reset', resetMetrics);
+metricsRoutes.get('/start', startMetrics);
+metricsRoutes.get('/stop', stopMetrics);
+metricsRoutes.get('/status', statusMetrics);
 export default metricsRoutes;

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

@@ -52,3 +52,38 @@ export const findTelemetry = (req, res) => {
         res.send({ spansCount: spans.length, spans: spans });
     });
 };
+export const insertTracesToDb = async (req, res) => {
+    const jsonContent = req.body.spans;
+    const resetData = req.query.reset === 'true';
+    if (!Array.isArray(jsonContent)) {
+        res.status(400).send({ error: 'Invalid data format. Expected an array of JSON objects.' });
+        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
+    });
+    try {
+        let message = '';
+        if (resetData) {
+            globalOasTlmConfig.dynamicSpanExporter.exporter.reset();
+            message += 'Traces Database reset. ';
+        }
+        await new Promise((resolve, reject) => {
+            globalOasTlmConfig.dynamicSpanExporter.exporter.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 });
+    }
+    catch (err) {
+        console.error(err);
+        res.status(500).send({ error: 'Failed to reset and insert data', details: err.message });
+    }
+};

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

@@ -1,7 +1,8 @@
 import { Router } from 'express';
-import { startTelemetry, stopTelemetry, statusTelemetry, resetTelemetry, listTelemetry, findTelemetry } from './traceController.js';
+import { startTelemetry, stopTelemetry, statusTelemetry, resetTelemetry, listTelemetry, findTelemetry, insertTracesToDb } from './traceController.js';
 export const traceRoutes = Router();
 traceRoutes.get('/', listTelemetry);
+traceRoutes.post('/', insertTracesToDb);
 traceRoutes.post('/find', findTelemetry);
 // Telemetry Control
 traceRoutes.get('/start', startTelemetry);

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

@@ -3,4 +3,15 @@ import { specLoader, heapStats } from './utilController.js';
 export const utilsRoutes = Router();
 utilsRoutes.get('/spec', specLoader);
 utilsRoutes.get('/heapStats', heapStats);
+utilsRoutes.get('/generateLog', (req, res) => {
+    const log = req.query.log || 'Default log message';
+    console.log('Generated log:', log);
+    res.send({ message: 'Log generated', log: log });
+});
+utilsRoutes.get('/wait/:seconds?', async (req, res) => {
+    const seconds = parseInt(req.params.seconds ?? "1", 10);
+    const waitTime = isNaN(seconds) ? 1 : seconds;
+    await new Promise(resolve => setTimeout(resolve, waitTime * 1000));
+    res.send({ waited: waitTime });
+});
 export default utilsRoutes;

package/dist/esm/tlmRoutes.js

@@ -24,7 +24,7 @@ export const configureRoutes = (router) => {
         if (req.body !== undefined) {
             return next(); // Already parsed, no need to parse again.
         }
-        return json()(req, res, next);
+        return json({ limit: '10mb' })(req, res, next);
     });
     const allAuthMiddlewares = getWrappedMiddlewares(() => globalOasTlmConfig.authEnabled, [cookieParser(), authRoutes, authMiddleware]);
     const baseURL = globalOasTlmConfig.baseURL;

package/dist/types/exporters/InMemoryDBMetricsExporter.d.ts

@@ -12,4 +12,10 @@ export declare class InMemoryDBMetricsExporter {
     find(search: any, callback: any): void;
     reset(): void;
     getFinishedMetrics(): import("@seald-io/nedb").Document<Record<string, any>>[];
+    /**
+     * Inserts metrics into the in-memory database.
+     * @param metrics - The metrics to insert.
+     * @param callback - The callback to execute after insertion.
+     */
+    insert(metrics: any[], callback: (err: any, newDocs: any[]) => void): void;
 }

package/dist/types/exporters/InMemoryDbExporter.d.ts

@@ -21,4 +21,10 @@ export declare class InMemoryExporter implements OasTlmExporter {
     find(search: any, callback: any): void;
     reset(): void;
     getFinishedSpans(): import("@seald-io/nedb").Document<Record<string, any>>[];
+    /**
+     * Inserts spans into the in-memory database.
+     * @param spans - The spans to insert.
+     * @param callback - The callback to execute after insertion.
+     */
+    insert(spans: any[], callback: (err: any, newDocs: any[]) => void): void;
 }

package/dist/types/exporters/InMemoryLogRecordExporter.d.ts

@@ -3,6 +3,7 @@ import { ReadableLogRecord, LogRecordExporter } from '@opentelemetry/sdk-logs';
 export declare class InMemoryLogRecordExporter implements LogRecordExporter {
     private _db;
     private _miniSearch;
+    private _stopped;
     constructor();
     /**
      * Export logs.
@@ -16,7 +17,11 @@ export declare class InMemoryLogRecordExporter implements LogRecordExporter {
      */
     shutdown(): Promise<void>;
     find(query: any, messageSearch: string | null, callback: (err: any, docs: any) => void): void;
-    getFinishedSpans(): any[];
+    insert(data: any[], callback: (err: any, newDocs: any[]) => void): void;
+    start(): void;
+    stop(): void;
+    isRunning(): boolean;
+    getFinishedLogs(): any[];
     /**
      *  @copyright The OpenTelemetry Authors
      *  @license Apache-2.0
@@ -24,4 +29,5 @@ export declare class InMemoryLogRecordExporter implements LogRecordExporter {
      * @param logRecord
      */
     private _formatLogRecord;
+    private _insertLogs;
 }

package/dist/types/tlm-log/logController.d.ts

@@ -2,3 +2,7 @@ import { Request, Response } from 'express';
 export declare const listLogs: (req: Request, res: Response) => Promise<void>;
 export declare const findLogs: (req: Request, res: Response) => Promise<void>;
 export declare const resetLogs: (req: Request, res: Response) => void;
+export declare const insertLogsToDb: (req: Request, res: Response) => Promise<void>;
+export declare const startLogs: (req: Request, res: Response) => void;
+export declare const stopLogs: (req: Request, res: Response) => void;
+export declare const statusLogs: (req: Request, res: Response) => void;

package/dist/types/tlm-metric/metricsController.d.ts

@@ -2,3 +2,7 @@ import { Request, Response } from 'express';
 export declare const listMetrics: (req: Request, res: Response) => Promise<void>;
 export declare const findMetrics: (req: Request, res: Response) => void;
 export declare const resetMetrics: (req: Request, res: Response) => void;
+export declare const insertMetricsToDb: (req: Request, res: Response) => Promise<void>;
+export declare const startMetrics: (req: Request, res: Response) => void;
+export declare const stopMetrics: (req: Request, res: Response) => void;
+export declare const statusMetrics: (req: Request, res: Response) => void;

package/dist/types/tlm-trace/traceController.d.ts

@@ -5,3 +5,4 @@ export declare const statusTelemetry: (req: Request, res: Response) => void;
 export declare const resetTelemetry: (req: Request, res: Response) => void;
 export declare const listTelemetry: (req: Request, res: Response) => Promise<void>;
 export declare const findTelemetry: (req: Request, res: Response) => void;
+export declare const insertTracesToDb: (req: Request, res: Response) => Promise<void>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oas-tools/oas-telemetry",
-  "version": "0.7.0-alpha.1",
+  "version": "0.7.0-alpha.2",
   "description": "Automatically collects and stores telemetry data in memory using OpenTelemetry. Just import the Express middleware to access it through the built-in REST API or web UI—no extra setup required.",
   "author": "Manuel Otero",
   "contributors": [
@@ -19,6 +19,8 @@
     "lint": "eslint --ext .ts . --fix"
   },
   "files": [
+    ".env.example",
+    "NOTICE",
     "dist"
   ],
   "main": "./dist/cjs/index.cjs",