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

package/dist/cjs/tlmRoutes.cjs

@@ -0,0 +1,79 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.configureRoutes = void 0;
+var _express = require("express");
+var _logger = _interopRequireDefault(require("./utils/logger.cjs"));
+var _cors = _interopRequireDefault(require("cors"));
+var _config = require("./config.cjs");
+var _metricsRoutes = _interopRequireDefault(require("./tlm-metric/metricsRoutes.cjs"));
+var _cookieParser = _interopRequireDefault(require("cookie-parser"));
+var _authRoutes = _interopRequireDefault(require("./tlm-auth/authRoutes.cjs"));
+var _uiRoutes = _interopRequireDefault(require("./tlm-ui/uiRoutes.cjs"));
+var _traceRoutes = _interopRequireDefault(require("./tlm-trace/traceRoutes.cjs"));
+var _authMiddleware = require("./tlm-auth/authMiddleware.cjs");
+var _utilRoutes = _interopRequireDefault(require("./tlm-util/utilRoutes.cjs"));
+var _logRoutes = _interopRequireDefault(require("./tlm-log/logRoutes.cjs"));
+var _aiRoutes = _interopRequireDefault(require("./tlm-ai/aiRoutes.cjs"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const configureRoutes = router => {
+  if (process.env.OASTLM_ENV === 'development') {
+    _logger.default.info("Running in development mode, enabling CORS for all origins");
+    router.use((0, _cors.default)({
+      origin: '*',
+      // Permitir todas las solicitudes en desarrollo
+      methods: ['GET', 'POST', 'PUT', 'DELETE'],
+      allowedHeaders: ['Content-Type', 'Authorization']
+    }));
+  }
+  router.use((req, res, next) => {
+    if (req.body !== undefined) {
+      return next(); // Already parsed, no need to parse again.
+    }
+    return (0, _express.json)()(req, res, next);
+  });
+  const allAuthMiddlewares = getWrappedMiddlewares(() => _config.globalOasTlmConfig.authEnabled, [(0, _cookieParser.default)(), _authRoutes.default, _authMiddleware.authMiddleware]);
+  const baseURL = _config.globalOasTlmConfig.baseURL;
+  router.use(baseURL, allAuthMiddlewares);
+  // WARNING: This path must be the same as the one used in the UI package App.tsx "oas-telemetry-ui"
+  router.use(baseURL + "/traces", _traceRoutes.default);
+  router.use(baseURL + "/metrics", _metricsRoutes.default);
+  router.use(baseURL + "/logs", _logRoutes.default);
+  router.use(baseURL + "/ai", getWrappedMiddlewares(() => process.env.OASTLM_AI_OPENAI_API_KEY !== null && process.env.OASTLM_AI_OPENAI_API_KEY !== "", [_aiRoutes.default]));
+  router.use(baseURL + "/oas-telemetry-ui", _uiRoutes.default);
+  router.use(baseURL + "/utils", _utilRoutes.default);
+  //redirect to the UI when accessing the base URL
+  router.get(baseURL, (req, res) => {
+    res.redirect(baseURL + "/oas-telemetry-ui");
+  });
+};
+/**
+ * This function wraps the provided middleware functions with a condition callback.
+ * If the condition callback returns true, the middleware/router will be executed.
+ * If the condition callback returns false, the middleware/router will be skipped.
+ *
+ * @callback {function} conditionCallback A callback function that returns a boolean to determine if the middleware should be used.
+ * @param {Array} middlewares An array of middleware or routers to be wrapped.
+ * @returns {Array} An array of wrapped middleware functions.
+ */
+exports.configureRoutes = configureRoutes;
+function getWrappedMiddlewares(conditionCallback, middlewares) {
+  return middlewares.map(middleware => {
+    return function (req, res, next) {
+      if (conditionCallback()) {
+        if (typeof middleware === 'function') {
+          // look for handle property, if it exists, it's a router. If not call middleware
+          if (middleware.handle) {
+            middleware.handle(req, res, next);
+          } else {
+            middleware(req, res, next);
+          }
+        }
+      } else {
+        next();
+      }
+    };
+  });
+}

package/dist/cjs/types/index.cjs

@@ -0,0 +1,8 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+;
+;
+;

package/dist/cjs/utils/circular.cjs

@@ -0,0 +1,90 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.applyNesting = applyNesting;
+exports.convertToNestedObject = convertToNestedObject;
+exports.removeCircularRefs = removeCircularRefs;
+function removeCircularRefs(obj) {
+  // const seen = new WeakMap(); // Used to keep track of visited objects
+  // Replacer function to handle circular references
+  function replacer(key, value) {
+    if (key === "_spanProcessor") {
+      return "oas-telemetry skips this field to avoid circular reference";
+    }
+    // GENERIC CIRCULAR REFERENCE HANDLING
+    // if (typeof value === "object" && value !== null) {
+    //     // If the object has been visited before, return the name prefixed with "CIRCULAR+"
+    //     if (seen.has(value)) {
+    //         return `CIRCULAR${key}`;
+    //     }
+    //     seen.set(value, key); // Mark the object as visited with its name
+    // }
+    return value;
+  }
+  // Convert the object to a string and then parse it back
+  // This will trigger the replacer function to handle circular references
+  const jsonString = JSON.stringify(obj, replacer);
+  return JSON.parse(jsonString);
+}
+/**
+ * Recursively converts dot-separated keys in an object to nested objects.
+ *
+ * @param {any} obj - The object to process.
+ * @returns {any} - The object with all dot-separated keys converted to nested objects.
+ * @example
+ * // Input:
+ * // {
+ * //   "http.method": "GET",
+ * //   "http.url": "http://example.com",
+ * //   "nested.obj.key": "value"
+ * // }
+ * // Output:
+ * // {
+ * //   "http": {
+ * //     "method": "GET",
+ * //     "url": "http://example.com"
+ * //   },
+ * //   "nested": {
+ * //     "obj": {
+ * //       "key": "value"
+ * //     }
+ * //   }
+ * // }
+ */
+function convertToNestedObject(obj) {
+  const result = {};
+  for (const key in obj) {
+    const keys = key.split('.');
+    let temp = result;
+    for (let i = 0; i < keys.length; i++) {
+      const currentKey = keys[i];
+      if (i === keys.length - 1) {
+        // Last key, set the value
+        temp[currentKey] = obj[key];
+      } else {
+        // Intermediate key, ensure the object exists
+        if (!temp[currentKey]) {
+          temp[currentKey] = {};
+        }
+        temp = temp[currentKey];
+      }
+    }
+  }
+  return result;
+}
+/**
+ * Applies nesting to all dot-separated keys within an object.
+ */
+function applyNesting(obj) {
+  for (const key in obj) {
+    const value = obj[key];
+    if (Array.isArray(value)) {
+      obj[key] = value.map(item => typeof item === 'object' && item !== null ? applyNesting(item) : item);
+    } else if (typeof value === 'object' && value !== null) {
+      obj[key] = applyNesting(value);
+    }
+  }
+  return convertToNestedObject(obj);
+}

package/dist/cjs/utils/logger.cjs

@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _dotenv = _interopRequireDefault(require("dotenv"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+_dotenv.default.config();
+const LOG_LEVELS = ['DEBUG', 'INFO', 'WARN', 'ERROR', 'NONE'];
+const currentLogLevel = (process.env.OASTLM_LOG_LEVEL || 'INFO').toUpperCase();
+const serviceName = process.env.OASTLM_SERVICE_NAME || 'OAS-TLM';
+function log(level, ...messages) {
+  if (LOG_LEVELS.indexOf(level) >= LOG_LEVELS.indexOf(currentLogLevel)) {
+    const timestamp = new Date().toISOString();
+    console.log(`${timestamp} [${serviceName}] [${level}]:`, ...messages);
+  }
+}
+var _default = exports.default = {
+  debug: (...messages) => log('DEBUG', ...messages),
+  info: (...messages) => log('INFO', ...messages),
+  log: (...messages) => log('INFO', ...messages),
+  // Alias for info
+  warn: (...messages) => log('WARN', ...messages),
+  error: (...messages) => log('ERROR', ...messages),
+  currentLogLevel
+};
+module.exports = exports.default;

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

@@ -1,23 +1,20 @@
-import { metrics } from "@opentelemetry/api";
-import DynamicExporter from "./exporters/dynamicExporter.js";
-import { InMemoryDBMetricsExporter } from "./exporters/InMemoryDBMetricsExporter.js";
-
-//Environment variables
-//OASTLM_MODULE_DISABLED = 'true' //Disables the module (empty middleware and no tracing)
-
-export const globalOasTlmConfig = {
-    dynamicExporter: new DynamicExporter(),
-    metricsExporter: new InMemoryDBMetricsExporter(),
-    systemMetricsInterval: 1000 * 5, // 5 seconds
-    baseURL: "/telemetry",
-    spec: null,
-    specFileName: "",
-    autoActivate: true,
-    authEnabled: false,
-    apiKeyMaxAge: 1000 * 60 * 60, // 1 hour
-    password: "oas-telemetry-password",
-    jwtSecret: "oas-telemetry-secret",
-};
-//5 name alternatives. one for globals 
-
-export default {globalOasTlmConfig}
+import DynamicExporter from "./exporters/dynamicExporter.js";
+import { InMemoryDBMetricsExporter } from "./exporters/InMemoryDBMetricsExporter.js";
+import { InMemoryLogRecordExporter } from "./exporters/InMemoryLogRecordExporter.js";
+//Environment variables
+//OASTLM_MODULE_DISABLED = 'true' //Disables the module (empty middleware and no tracing)
+export const globalOasTlmConfig = {
+    dynamicSpanExporter: new DynamicExporter(),
+    metricsExporter: new InMemoryDBMetricsExporter(),
+    logExporter: new InMemoryLogRecordExporter(),
+    metricsExporterInterval: 1000 * 30, // milliseconds
+    baseURL: "/telemetry",
+    spec: null,
+    specFileName: "",
+    autoActivate: true,
+    authEnabled: false,
+    apiKeyMaxAge: 1000 * 60 * 60, // 1 hour
+    password: "oas-telemetry-password",
+    jwtSecret: "oas-telemetry-secret",
+};
+export default { globalOasTlmConfig };

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

@@ -1,111 +1,57 @@
-import { ExportResultCode } from '@opentelemetry/core';
-import dataStore from '@seald-io/nedb';
-
-export class InMemoryDBMetricsExporter {
-    constructor() {
-        this._metrics = new dataStore();
-        this._stopped = false;
-    }
-
-    export(metrics, resultCallback) {
-        try {
-            if (!this._stopped) {
-                // metrics = metrics?.scopeMetrics;
-                // const cleanMetrics = metrics.map(metric => applyNesting(metric));
-                this._metrics.insert(metrics, (err, newDoc) => {
-                    if (err) {
-                        console.error('Insertion Error:', err); 
-                        return;
-                    }
-                });
-            }
-            setTimeout(() => resultCallback({ code: ExportResultCode.SUCCESS }), 0);
-        } catch (error) {
-            console.error('Error exporting metrics\n' + error.message + '\n' + error.stack);
-            return resultCallback({
-                code: ExportResultCode.FAILED,
-                error: new Error('Error exporting metrics\n' + error.message + '\n' + error.stack),
-            });
-        }
-    }
-
-    start() {
-        this._stopped = false;
-    }
-
-    stop() {
-        this._stopped = true;
-    }
-
-    isRunning() {
-        return !this._stopped;
-    }
-
-    shutdown() {
-        this._stopped = true;
-        this._metrics = new dataStore();
-        return this.forceFlush();
-    }
-
-    forceFlush() {
-        return Promise.resolve();
-    }
-
-    find(search, callback) {
-        this._metrics.find(search, callback);
-    }
-
-    reset() {
-        this._metrics = new dataStore();
-    }
-
-    getFinishedMetrics() {
-        return this._metrics.getAllData();
-    }
-}
-
-function convertToNestedObject(obj) {
-    const result = {};
-
-    for (const key in obj) {
-        const keys = key.split('.');
-        let temp = result;
-
-        for (let i = 0; i < keys.length; i++) {
-            const currentKey = keys[i];
-
-            if (i === keys.length - 1) {
-                // Last key, set the value
-                temp[currentKey] = obj[key];
-            } else {
-                // Intermediate key, ensure the object exists
-                if (!temp[currentKey]) {
-                    temp[currentKey] = {};
-                }
-                temp = temp[currentKey];
-            }
-        }
-    }
-
-    return result;
-}
-
-/**
- * Applies nesting to all dot-separated keys within an object.
- * 
- * @param {Object} obj - The object to apply nesting to.
- * @returns {Object} - The transformed object with nested structures.
- */
-function applyNesting(obj) {
-
-
-        for (const key in obj) {
-            if (typeof obj[key] === 'object' && obj[key] !== null) {
-                obj[key] = applyNesting(obj[key]);
-            }
-        }
-
-
-    return obj;
-}
-
+import { ExportResultCode } from '@opentelemetry/core';
+import dataStore from '@seald-io/nedb';
+import { applyNesting } from '../utils/circular.js';
+export class InMemoryDBMetricsExporter {
+    constructor() {
+        this._metrics = new dataStore();
+        this._stopped = false;
+    }
+    export(metrics, resultCallback) {
+        try {
+            if (!this._stopped) {
+                // metrics = metrics?.scopeMetrics;
+                const cleanMetrics = applyNesting(metrics);
+                this._metrics.insert(cleanMetrics, (err, _newDoc) => {
+                    if (err) {
+                        console.error('Insertion Error:', err);
+                        return;
+                    }
+                });
+            }
+            setTimeout(() => resultCallback({ code: ExportResultCode.SUCCESS }), 0);
+        }
+        catch (error) {
+            console.error('Error exporting metrics\n' + error.message + '\n' + error.stack);
+            return resultCallback({
+                code: ExportResultCode.FAILED,
+                error: new Error('Error exporting metrics\n' + error.message + '\n' + error.stack),
+            });
+        }
+    }
+    start() {
+        this._stopped = false;
+    }
+    stop() {
+        this._stopped = true;
+    }
+    isRunning() {
+        return !this._stopped;
+    }
+    shutdown() {
+        this._stopped = true;
+        this._metrics = new dataStore();
+        return this.forceFlush();
+    }
+    forceFlush() {
+        return Promise.resolve();
+    }
+    find(search, callback) {
+        this._metrics.find(search, callback);
+    }
+    reset() {
+        this._metrics = new dataStore();
+    }
+    getFinishedMetrics() {
+        return this._metrics.getAllData();
+    }
+}

package/dist/esm/exporters/InMemoryDbExporter.js

@@ -0,0 +1,87 @@
+import { ExportResultCode } from '@opentelemetry/core';
+//import in memory database
+import dataStore from '@seald-io/nedb';
+import logger from '../utils/logger.js';
+import { applyNesting, removeCircularRefs } from '../utils/circular.js';
+export class InMemoryExporter {
+    constructor() {
+        // Overrided by dynamic exporter
+        this.plugins = [];
+        this._spans = new dataStore();
+        this._stopped = true;
+    }
+    ;
+    export(readableSpans, resultCallback) {
+        try {
+            if (!this._stopped) {
+                // Prepare spans to be inserted into the in-memory database (remove circular references and convert to nested objects)
+                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
+                // Insert spans into the in-memory database
+                this._spans.insert(cleanSpans, (err, _newDoc) => {
+                    // p = {name, plugin
+                    this.plugins.forEach((pluginResource, i) => {
+                        cleanSpans.forEach((span) => {
+                            logger.debug(`Sending span <${span._id}> to plugin (Plugin #${i}) <${pluginResource.name}>`);
+                            logger.debug(`Span: \n<${JSON.stringify(span, null, 2)}`);
+                            //TODO: This should be called newSpan instead of newTrace
+                            pluginResource.plugin.newTrace(span);
+                        });
+                    });
+                    if (err) {
+                        console.error(err);
+                        return;
+                    }
+                });
+            }
+            setTimeout(() => resultCallback({ code: ExportResultCode.SUCCESS }), 0);
+        }
+        catch (error) {
+            console.error('Error exporting spans\n' + error.message + '\n' + error.stack);
+            return resultCallback({
+                code: ExportResultCode.FAILED,
+                error: new Error('Error exporting spans\n' + error.message + '\n' + error.stack),
+            });
+        }
+    }
+    ;
+    start() {
+        this._stopped = false;
+    }
+    ;
+    stop() {
+        this._stopped = true;
+    }
+    ;
+    isRunning() {
+        return !this._stopped;
+    }
+    ;
+    shutdown() {
+        this._stopped = true;
+        this._spans = new dataStore();
+        return this.forceFlush();
+    }
+    ;
+    /**
+     * Exports any pending spans in the exporter
+     */
+    forceFlush() {
+        return Promise.resolve();
+    }
+    ;
+    //err,docs
+    find(search, callback) {
+        this._spans.find(search, callback);
+    }
+    reset() {
+        this._spans = new dataStore();
+    }
+    ;
+    getFinishedSpans() {
+        return this._spans.getAllData();
+    }
+    ;
+}

package/dist/esm/exporters/InMemoryLogRecordExporter.js

@@ -0,0 +1,95 @@
+import { hrTimeToMicroseconds } from '@opentelemetry/core';
+import { ExportResultCode } from '@opentelemetry/core';
+import { removeCircularRefs, applyNesting } from '../utils/circular.js';
+import Datastore from '@seald-io/nedb';
+import MiniSearch from 'minisearch';
+export class InMemoryLogRecordExporter {
+    constructor() {
+        this._db = new Datastore();
+        this._miniSearch = new MiniSearch({
+            fields: ['body'],
+            storeFields: ['_id'],
+            idField: '_id',
+        });
+    }
+    /*
+    * SUPER WARNING:
+    * Do NOT use console.log, console.error, or any logger inside this class's export function.
+    * Doing so will cause an infinite loop.
+    * Only console.dir is allowed, as it is not tracked by our log export implementation.
+    */
+    /**
+     * Export logs.
+     * @param logs
+     * @param resultCallback
+     */
+    export(logs, resultCallback) {
+        const logsToInsert = logs.map(logRecord => {
+            // Remove circular references first, then apply nesting, then export info
+            const formattedLog = this._formatLogRecord(logRecord);
+            const cleanedLog = removeCircularRefs(formattedLog);
+            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 });
+        });
+    }
+    reset() {
+        this._db = new Datastore();
+        this._miniSearch = new MiniSearch({
+            fields: ['body'],
+            storeFields: ['_id'],
+            idField: '_id',
+        });
+    }
+    /**
+     * Shutdown the exporter.
+     */
+    async shutdown() {
+        this._db = null;
+        this._miniSearch = null;
+    }
+    find(query, messageSearch, callback) {
+        if (messageSearch) {
+            const searchResults = this._miniSearch.search(messageSearch);
+            const ids = searchResults.map((result) => result._id);
+            console.dir(`MiniSearch found ${ids.length} results for search term "${messageSearch}"`, { depth: 3 });
+            // Add MiniSearch results to the query
+            query._id = { $in: ids };
+        }
+        this._db.find(query, callback);
+    }
+    getFinishedSpans() {
+        return this._db.getAllData();
+    }
+    /**
+     *  @copyright The OpenTelemetry Authors
+     *  @license Apache-2.0
+     * converts logRecord info into more readable format
+     * @param logRecord
+     */
+    _formatLogRecord(logRecord) {
+        return {
+            resource: {
+                attributes: logRecord.resource.attributes,
+            },
+            instrumentationScope: logRecord.instrumentationScope,
+            timestamp: hrTimeToMicroseconds(logRecord.hrTime) || Date.now(),
+            traceId: logRecord.spanContext?.traceId,
+            spanId: logRecord.spanContext?.spanId,
+            traceFlags: logRecord.spanContext?.traceFlags,
+            severityText: logRecord.severityText,
+            severityNumber: logRecord.severityNumber,
+            body: logRecord.body,
+            attributes: logRecord.attributes,
+        };
+    }
+}