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

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

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

@@ -1,47 +1,38 @@
-export class ConsoleExporter {
-
-    // PLUGIN SYSTEM -----------------------------------------------------------
-    plugins = [];
-
-    // OPEN TELEMETRY EXPORTER INTERFACE ---------------------------------------
-    export(readableSpans, resultCallback) {
-        console.log('ConsoleExporter | Received spans: ', readableSpans.length);
-        setTimeout(() => resultCallback({ code: 0 }), 0);
-    }
-
-    shutdown() {
-        return this.forceFlush();
-    }
-
-    forceFlush() {
-        return Promise.resolve();
-    }
-
-    // OAS-TOOLS OAS-TELEMETRY EXPORTER INTERFACE ---------------------------------------
-
-    start() {
-        console.log("Exporter started");
-    }
-
-    stop() {
-        console.log("Exporter stopped");
-    }
-
-    reset() {
-        console.log("Exporter reset");
-    }
-
-    isRunning() {
-        return true;
-    }
-
-    find(search, callback) {
-        console.log("Getting finished spans");
-        callback(null, []);
-        return [];
-    }
-
-    async getFinishedSpans() {
-        return [];
-    }
-}
+export class ConsoleExporter {
+    constructor() {
+        // PLUGIN SYSTEM -----------------------------------------------------------
+        this.plugins = [];
+    }
+    // OPEN TELEMETRY EXPORTER INTERFACE ---------------------------------------
+    export(readableSpans, resultCallback) {
+        console.log('ConsoleExporter | Received spans: ', readableSpans.length);
+        setTimeout(() => resultCallback({ code: 0 }), 0);
+    }
+    shutdown() {
+        return this.forceFlush();
+    }
+    forceFlush() {
+        return Promise.resolve();
+    }
+    // OAS-TOOLS OAS-TELEMETRY EXPORTER INTERFACE ---------------------------------------
+    start() {
+        console.log("Exporter started");
+    }
+    stop() {
+        console.log("Exporter stopped");
+    }
+    reset() {
+        console.log("Exporter reset");
+    }
+    isRunning() {
+        return true;
+    }
+    find(search, callback) {
+        console.log("Getting finished spans");
+        callback(null, []);
+        return [];
+    }
+    getFinishedSpans() {
+        return [];
+    }
+}