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

package/dist/{config.cjs → cjs/config.cjs}

@@ -4,18 +4,18 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.globalOasTlmConfig = exports.default = void 0;
-var _api = require("@opentelemetry/api");
 var _dynamicExporter = _interopRequireDefault(require("./exporters/dynamicExporter.cjs"));
 var _InMemoryDBMetricsExporter = require("./exporters/InMemoryDBMetricsExporter.cjs");
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+var _InMemoryLogRecordExporter = require("./exporters/InMemoryLogRecordExporter.cjs");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 //Environment variables
 //OASTLM_MODULE_DISABLED = 'true' //Disables the module (empty middleware and no tracing)
-
 const globalOasTlmConfig = exports.globalOasTlmConfig = {
-  dynamicExporter: new _dynamicExporter.default(),
+  dynamicSpanExporter: new _dynamicExporter.default(),
   metricsExporter: new _InMemoryDBMetricsExporter.InMemoryDBMetricsExporter(),
-  systemMetricsInterval: 1000 * 5,
-  // 5 seconds
+  logExporter: new _InMemoryLogRecordExporter.InMemoryLogRecordExporter(),
+  metricsExporterInterval: 1000 * 30,
+  // milliseconds
   baseURL: "/telemetry",
   spec: null,
   specFileName: "",
@@ -26,7 +26,6 @@ const globalOasTlmConfig = exports.globalOasTlmConfig = {
   password: "oas-telemetry-password",
   jwtSecret: "oas-telemetry-secret"
 };
-//5 name alternatives. one for globals 
 var _default = exports.default = {
   globalOasTlmConfig
 };

package/dist/{exporters → cjs/exporters}/InMemoryDBMetricsExporter.cjs

@@ -6,7 +6,8 @@ Object.defineProperty(exports, "__esModule", {
 exports.InMemoryDBMetricsExporter = void 0;
 var _core = require("@opentelemetry/core");
 var _nedb = _interopRequireDefault(require("@seald-io/nedb"));
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+var _circular = require("../utils/circular.cjs");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 class InMemoryDBMetricsExporter {
   constructor() {
     this._metrics = new _nedb.default();
@@ -16,8 +17,8 @@ class InMemoryDBMetricsExporter {
     try {
       if (!this._stopped) {
         // metrics = metrics?.scopeMetrics;
-        // const cleanMetrics = metrics.map(metric => applyNesting(metric));
-        this._metrics.insert(metrics, (err, newDoc) => {
+        const cleanMetrics = (0, _circular.applyNesting)(metrics);
+        this._metrics.insert(cleanMetrics, (err, _newDoc) => {
           if (err) {
             console.error('Insertion Error:', err);
             return;
@@ -62,40 +63,4 @@ class InMemoryDBMetricsExporter {
     return this._metrics.getAllData();
   }
 }
-exports.InMemoryDBMetricsExporter = InMemoryDBMetricsExporter;
-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;
-}
+exports.InMemoryDBMetricsExporter = InMemoryDBMetricsExporter;

package/dist/cjs/exporters/InMemoryDbExporter.cjs

@@ -0,0 +1,87 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.InMemoryExporter = void 0;
+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");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+//import in memory database
+
+class InMemoryExporter {
+  constructor() {
+    // Overrided by dynamic exporter
+    this.plugins = [];
+    this._spans = new _nedb.default();
+    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 => (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
+        // 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.default.debug(`Sending span <${span._id}> to plugin (Plugin #${i}) <${pluginResource.name}>`);
+              _logger.default.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: _core.ExportResultCode.SUCCESS
+      }), 0);
+    } catch (error) {
+      console.error('Error exporting spans\n' + error.message + '\n' + error.stack);
+      return resultCallback({
+        code: _core.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 _nedb.default();
+    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 _nedb.default();
+  }
+  getFinishedSpans() {
+    return this._spans.getAllData();
+  }
+}
+exports.InMemoryExporter = InMemoryExporter;

package/dist/cjs/exporters/InMemoryLogRecordExporter.cjs

@@ -0,0 +1,110 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.InMemoryLogRecordExporter = void 0;
+var _core = require("@opentelemetry/core");
+var _circular = require("../utils/circular.cjs");
+var _nedb = _interopRequireDefault(require("@seald-io/nedb"));
+var _minisearch = _interopRequireDefault(require("minisearch"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class InMemoryLogRecordExporter {
+  constructor() {
+    this._db = new _nedb.default();
+    this._miniSearch = new _minisearch.default({
+      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 = (0, _circular.removeCircularRefs)(formattedLog);
+      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
+      });
+    });
+  }
+  reset() {
+    this._db = new _nedb.default();
+    this._miniSearch = new _minisearch.default({
+      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: (0, _core.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
+    };
+  }
+}
+exports.InMemoryLogRecordExporter = InMemoryLogRecordExporter;

package/dist/{exporters → cjs/exporters}/consoleExporter.cjs

@@ -4,13 +4,10 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.ConsoleExporter = void 0;
-function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
-function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
 class ConsoleExporter {
   constructor() {
     // PLUGIN SYSTEM -----------------------------------------------------------
-    _defineProperty(this, "plugins", []);
+    this.plugins = [];
   }
   // OPEN TELEMETRY EXPORTER INTERFACE ---------------------------------------
   export(readableSpans, resultCallback) {
@@ -25,9 +22,7 @@ class ConsoleExporter {
   forceFlush() {
     return Promise.resolve();
   }
-
   // OAS-TOOLS OAS-TELEMETRY EXPORTER INTERFACE ---------------------------------------
-
   start() {
     console.log("Exporter started");
   }
@@ -45,7 +40,7 @@ class ConsoleExporter {
     callback(null, []);
     return [];
   }
-  async getFinishedSpans() {
+  getFinishedSpans() {
     return [];
   }
 }

package/dist/{exporters → cjs/exporters}/dynamicExporter.cjs

@@ -5,26 +5,20 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = exports.DynamicExporter = void 0;
 var _consoleExporter = require("./consoleExporter.cjs");
-function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
-function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
-/**
- * DynamicExporter is a class that can be used to dynamically change the exporter used by OpenTelemetry.
- * This is useful when you want to change the exporter at runtime.
- * Links start, stop and export methods to the Real exporter.
+/**
+ * DynamicExporter is a class that can be used to dynamically change the exporter used by OpenTelemetry.
+ * This is useful when you want to change the exporter at runtime.
+ * Links start, stop and export methods to the Real exporter.
  */
 class DynamicExporter {
-  /** 
-   * @returns {Array<PluginResource>} Returns the list of plugins registered in the exporter
+  /**
+   * Returns the list of plugins registered in the exporter
    */
   getPlugins() {
     return this.exporter.plugins;
   }
-
-  /**
-   * Registers a plugin in the exporter
-   * @param {PluginResource} pluginResource The plugin to be registered
-   * @returns {void}
+  /**
+   * Registers a plugin in the exporter
    */
   pushPlugin(pluginResource) {
     if (!this.exporter.plugins) {
@@ -33,7 +27,7 @@ class DynamicExporter {
     this.exporter.plugins.push(pluginResource);
   }
   activatePlugin(pluginId) {
-    let plugins = this.exporter.plugins;
+    const plugins = this.exporter.plugins;
     if (plugins) {
       // plugin.active = true;
       plugins.forEach(plugin => {
@@ -44,8 +38,7 @@ class DynamicExporter {
     }
   }
   constructor() {
-    _defineProperty(this, "exporter", void 0);
-    let defaultExporter = new _consoleExporter.ConsoleExporter();
+    const defaultExporter = new _consoleExporter.ConsoleExporter();
     this.exporter = defaultExporter;
     this.export = (readableSpans, resultCallback) => defaultExporter.export(readableSpans, resultCallback);
     this.shutdown = () => defaultExporter.shutdown();
@@ -54,10 +47,10 @@ class DynamicExporter {
   changeExporter(newExporter) {
     this.exporter = newExporter;
     // OpenTelemetry methods
-    this.export = (readableSpans, resultCallback) => newExporter.export(readableSpans, resultCallback);
+    this.export = (readableSpan, resultCallback) => newExporter.export(readableSpan, resultCallback);
     this.shutdown = () => newExporter.shutdown();
     this.forceFlush = () => newExporter.forceFlush();
-    // Other methods should be called directly from the exporter: globalOasTlmConfig.dynamicExporter.exporter.method()
+    // Other methods should be called directly from the exporter: globalOasTlmConfig.dynamicSpanExporter.exporter.method()
   }
 }
 exports.DynamicExporter = DynamicExporter;

package/dist/cjs/index.cjs

@@ -0,0 +1,43 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = oasTelemetry;
+require("./instrumentation/index.cjs");
+var _config = require("./config.cjs");
+var _express = require("express");
+var _InMemoryDbExporter = require("./exporters/InMemoryDbExporter.cjs");
+var _logger = _interopRequireDefault(require("./utils/logger.cjs"));
+var _tlmRoutes = require("./tlmRoutes.cjs");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * Returns the Oas Telemetry middleware. The parameters are the same as `globalOasTlmConfig`.
+ * All parameters are optional. However, either `spec` or `specFileName` must be provided to enable endpoint filtering.
+ */
+function oasTelemetry(oasTlmInputConfig) {
+  const router = (0, _express.Router)();
+  if (process.env.OASTLM_MODULE_DISABLED === 'true') {
+    return router;
+  }
+  if (oasTlmInputConfig) {
+    _logger.default.info("User provided config");
+    // Override global config with user provided config
+    for (const key in _config.globalOasTlmConfig) {
+      _config.globalOasTlmConfig[key] = oasTlmInputConfig[key] ?? _config.globalOasTlmConfig[key];
+    }
+  }
+  _logger.default.info("BaseURL: ", _config.globalOasTlmConfig.baseURL);
+  _config.globalOasTlmConfig.dynamicSpanExporter.changeExporter(_config.globalOasTlmConfig.exporter ?? new _InMemoryDbExporter.InMemoryExporter());
+  if (_config.globalOasTlmConfig.spec) _logger.default.info(`Spec content provided`);else {
+    if (_config.globalOasTlmConfig.specFileName != "") _logger.default.info(`Spec file used for telemetry: ${_config.globalOasTlmConfig.specFileName}`);else {
+      console.error("No spec available !");
+    }
+  }
+  if (_config.globalOasTlmConfig.autoActivate) {
+    _config.globalOasTlmConfig.dynamicSpanExporter.exporter?.start();
+  }
+  (0, _tlmRoutes.configureRoutes)(router);
+  return router;
+}
+module.exports = exports.default;

package/dist/cjs/instrumentation/index.cjs

@@ -0,0 +1,28 @@
+"use strict";
+
+var _resources = require("@opentelemetry/resources");
+var _instrumentationHttp = require("@opentelemetry/instrumentation-http");
+var _semanticConventions = require("@opentelemetry/semantic-conventions");
+var _logger = _interopRequireDefault(require("../utils/logger.cjs"));
+var _logs = require("./logs.cjs");
+var _traces = require("./traces.cjs");
+var _instrumentation = require("@opentelemetry/instrumentation");
+var _metrics = require("./metrics.cjs");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+// import { NodeSDK } from '@opentelemetry/sdk-node';
+
+const oasTelemetryResource = (0, _resources.resourceFromAttributes)({
+  [_semanticConventions.ATTR_SERVICE_NAME]: 'oas-telemetry-service'
+});
+if (process.env.OASTLM_MODULE_DISABLED !== 'true') {
+  (0, _traces.initializeTraces)(oasTelemetryResource);
+  (0, _metrics.initializeMetrics)(oasTelemetryResource);
+  (0, _logs.initializeLogs)(oasTelemetryResource);
+  (0, _instrumentation.registerInstrumentations)({
+    instrumentations: [new _instrumentationHttp.HttpInstrumentation()
+    // new ExpressInstrumentation(),
+    ]
+  });
+} else {
+  _logger.default.info('🚫 OASTLM module is disabled, SDKs not initialized.');
+}

package/dist/cjs/instrumentation/logs.cjs

@@ -0,0 +1,46 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.initializeLogs = initializeLogs;
+var _sdkLogs = require("@opentelemetry/sdk-logs");
+var _apiLogs = require("@opentelemetry/api-logs");
+var _config = require("../config.cjs");
+var _logger = _interopRequireDefault(require("../utils/logger.cjs"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function initializeLogs(resource) {
+  // Create and configure LoggerProvider
+  const logExporter = _config.globalOasTlmConfig.logExporter;
+  const logRecordProcessor = new _sdkLogs.SimpleLogRecordProcessor(logExporter);
+  const loggerProvider = new _sdkLogs.LoggerProvider({
+    resource: resource,
+    processors: [logRecordProcessor]
+  });
+  // Get a logger instance
+  const loggerInstance = loggerProvider.getLogger('oas-telemetry'); // Use loggerProvider to get the logger
+  // Override console methods to emit logs via OpenTelemetry
+  const originalConsoleMethods = {
+    log: console.log,
+    warn: console.warn,
+    error: console.error,
+    info: console.info,
+    debug: console.debug
+  };
+  Object.keys(originalConsoleMethods).forEach(method => {
+    // @ts-expect-error yes
+    console[method] = (...args) => {
+      loggerInstance.emit({
+        severityNumber: _apiLogs.SeverityNumber[method.toUpperCase()] || _apiLogs.SeverityNumber.INFO,
+        severityText: method.toUpperCase(),
+        body: args.join(' '),
+        attributes: {
+          'source.source': `console.${method}`
+        }
+      });
+      // @ts-expect-error yes
+      originalConsoleMethods[method](...args);
+    };
+  });
+  _logger.default.info('✅ OpenTelemetry Logs initialized.');
+}

package/dist/cjs/instrumentation/metrics.cjs

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.initializeMetrics = initializeMetrics;
+var _sdkMetrics = require("@opentelemetry/sdk-metrics");
+var _logger = _interopRequireDefault(require("../utils/logger.cjs"));
+var _config = require("../config.cjs");
+var _hostMetrics = require("@opentelemetry/host-metrics");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function initializeMetrics(resource) {
+  const metricReader = new _sdkMetrics.PeriodicExportingMetricReader({
+    // exporter: new ConsoleMetricExporter(),
+    exporter: _config.globalOasTlmConfig.metricsExporter,
+    exportIntervalMillis: _config.globalOasTlmConfig.metricsExporterInterval
+  });
+  const meterProvider = new _sdkMetrics.MeterProvider({
+    resource: resource,
+    readers: [metricReader]
+  });
+  const hostMetrics = new _hostMetrics.HostMetrics({
+    meterProvider
+  });
+  hostMetrics.start();
+  _logger.default.info('✅ OpenTelemetry Metrics initialized.');
+}

package/dist/cjs/instrumentation/traces.cjs

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.initializeTraces = initializeTraces;
+var _logger = _interopRequireDefault(require("../utils/logger.cjs"));
+var _sdkTraceNode = require("@opentelemetry/sdk-trace-node");
+var _config = require("../config.cjs");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function initializeTraces(resource) {
+  const tracerProvider = new _sdkTraceNode.NodeTracerProvider({
+    resource: resource,
+    spanProcessors: [new _sdkTraceNode.BatchSpanProcessor(_config.globalOasTlmConfig.dynamicSpanExporter)]
+  });
+  // tracerProvider.addSpanProcessor();
+  tracerProvider.register();
+  _logger.default.info('✅ OpenTelemetry Traces initialized.');
+}

package/dist/{openTelemetry.cjs → cjs/openTelemetry.cjs}

@@ -5,21 +5,22 @@ var _resources = require("@opentelemetry/resources");
 var _instrumentationHttp = require("@opentelemetry/instrumentation-http");
 var _config = require("./config.cjs");
 var _systemMetrics = require("./systemMetrics.cjs");
+var _logger = _interopRequireDefault(require("./utils/logger.cjs"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 // import { getNodeAutoInstrumentations } from '@opentelemetry/auto-instrumentations-node';
 
 // Import system metrics functions
 
 // DynamicExporter allows changing to any exporter at runtime;
-const traceExporter = _config.globalOasTlmConfig.dynamicExporter;
+const dynamicSpanExporter = _config.globalOasTlmConfig.dynamicSpanExporter;
 // Alternative 1: Using NodeSDK
 const sdk = new _sdkNode.NodeSDK({
   resource: new _resources.Resource({
     service: 'oas-telemetry-service'
   }),
-  traceExporter,
+  traceExporter: dynamicSpanExporter,
   instrumentations: [new _instrumentationHttp.HttpInstrumentation()]
 });
-
 // Collect and export system metrics
 setInterval(() => {
   const cpuUsageData = (0, _systemMetrics.getCpuUsageData)();
@@ -33,20 +34,17 @@ setInterval(() => {
     memoryData,
     processMemoryData
   };
-
   // Export the collected metrics using the InMemoryDBMetricsExporter
   const inMemoryDbMetricExporter = _config.globalOasTlmConfig.metricsExporter;
-  inMemoryDbMetricExporter.export(metrics, result => {});
+  inMemoryDbMetricExporter.export(metrics, () => {});
 }, _config.globalOasTlmConfig.systemMetricsInterval);
-console.log('✅ OpenTelemetry System Metrics initialized.');
+_logger.default.info('✅ OpenTelemetry System Metrics initialized.');
 if (process.env.OASTLM_MODULE_DISABLED !== 'true') {
   sdk.start();
 }
-
 // Alternative 2:
 // const provider = new NodeTracerProvider();
 // provider.addSpanProcessor(new SimpleSpanProcessor(traceExporter));
-
 // if (process.env.OASTLM_MODULE_DISABLED !== 'true') {
 //   provider.register();
 //   registerInstrumentations({

package/dist/{systemMetrics.cjs → cjs/systemMetrics.cjs}

@@ -83,15 +83,15 @@ function getMemoryData() {
   const freeP = free / total;
   const usedP = used / total;
   return {
-    used: used,
-    free: free,
-    usedP: usedP,
-    freeP: freeP
+    used,
+    free,
+    usedP,
+    freeP
   };
 }
 function getProcessMemoryData() {
-  if (process.memoryUsage.rss) {
-    return process.memoryUsage.rss();
+  if (process.memoryUsage().rss) {
+    return process.memoryUsage().rss;
   }
-  return process.memoryUsage().rss;
+  return 0;
 }