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

package/dist/cjs/config/bootConfig.cjs

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.bootEnvVariables = void 0;
+var _dotenv = _interopRequireDefault(require("dotenv"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+if (process.env.NODE_ENV !== 'test') {
+  _dotenv.default.config();
+}
+// This variables can NOT be configured via oasTelemetry(config)
+// They are used at the import of the library
+const bootEnvVariables = exports.bootEnvVariables = {
+  OASTLM_BOOT_ENV: process.env.OASTLM_BOOT_ENV || process.env.NODE_ENV || 'production',
+  OASTLM_BOOT_MODULE_DISABLED: process.env.OASTLM_BOOT_MODULE_DISABLED === 'true',
+  OASTLM_BOOT_LOG_LEVEL: process.env.OASTLM_BOOT_LOG_LEVEL || 'INFO'
+};

package/dist/cjs/config/config.cjs

@@ -0,0 +1,145 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getConfig = exports.defaultConfig = void 0;
+var _lodash = _interopRequireDefault(require("lodash.merge"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+// Environment-level config (highest priority)
+// If NOT defined, it should return UNDEFINED so it dose not override the userConfig or defaultConfig.
+// Thats why we use getParsedEnvVar with no default value.
+const loadEnv = () => {
+  return {
+    general: {
+      baseUrl: getParsedEnvVar("OASTLM_CONFIG_GENERAL_BASE_URL"),
+      specFileName: getParsedEnvVar("OASTLM_CONFIG_GENERAL_SPEC_FILE_NAME")
+      // spec Not settable via env
+    },
+    auth: {
+      enabled: getParsedEnvVar("OASTLM_CONFIG_AUTH_ENABLED", v => v === "true"),
+      apiKeyMaxAge: getParsedEnvVar("OASTLM_CONFIG_AUTH_API_KEY_MAX_AGE", v => parseInt(v, 10)),
+      password: getParsedEnvVar("OASTLM_CONFIG_AUTH_PASSWORD"),
+      jwtSecret: getParsedEnvVar("OASTLM_CONFIG_AUTH_JWT_SECRET")
+    },
+    traces: {
+      memoryExporter: {
+        enabled: getParsedEnvVar("OASTLM_CONFIG_TRACES_MEMORY_EXPORTER_ENABLED", v => v === "true"),
+        retentionTimeSeconds: getParsedEnvVar("OASTLM_CONFIG_TRACES_MEMORY_EXPORTER_RETENTION_TIME_SECONDS", v => parseInt(v, 10))
+        // filters NOT settable via env
+      }
+    },
+    metrics: {
+      mainMetricReaderOptions: {
+        exportIntervalMillis: getParsedEnvVar("OASTLM_CONFIG_METRICS_MAIN_READER_EXPORT_INTERVAL", v => parseInt(v, 10))
+        // metricProducers NOT settable via env
+      },
+      memoryExporter: {
+        enabled: getParsedEnvVar("OASTLM_CONFIG_METRICS_MEMORY_EXPORTER_ENABLED", v => v === "true"),
+        retentionTimeSeconds: getParsedEnvVar("OASTLM_CONFIG_METRICS_MEMORY_EXPORTER_RETENTION_TIME_SECONDS", v => parseInt(v, 10))
+        // filters NOT settable via env
+      }
+    },
+    logs: {
+      memoryExporter: {
+        enabled: getParsedEnvVar("OASTLM_CONFIG_LOGS_MEMORY_EXPORTER_ENABLED", v => v === "true"),
+        retentionTimeSeconds: getParsedEnvVar("OASTLM_CONFIG_LOGS_MEMORY_EXPORTER_RETENTION_TIME_SECONDS", v => parseInt(v, 10))
+        // filters NOT settable via env
+      }
+    },
+    ai: {
+      openAIKey: getParsedEnvVar("OASTLM_CONFIG_AI_OPENAI_KEY"),
+      openAIModel: getParsedEnvVar("OASTLM_CONFIG_AI_OPENAI_MODEL", v => v || "gpt-3.5-turbo"),
+      extraContextPrompts: getParsedEnvVar("OASTLM_CONFIG_AI_EXTRA_CONTEXT_PROMPTS", v => v ? v.split(',') : [])
+    }
+  };
+};
+// This defines de OasTlmConfig type, which is used throughout the library.
+// Please ensure that all possible types are included here, not only the defaults.
+// e.g. .ai.openAIKey: null as string | null, default is null, but can be set to a string.
+// NOTE: Some BOOT environment variables (e.g., OASTLM_BOOT_MODULE_DISABLED) are accessed before this config is loaded.
+// This means certain settings may affect application startup behavior outside of this configuration system.
+const defaultConfig = exports.defaultConfig = {
+  general: {
+    baseUrl: "/telemetry",
+    specFileName: null,
+    // e.g. "oas.json" or null if not provided
+    spec: null,
+    // e.g. JSON.stringify(oasSpec) or null if not provided,
+    uiPath: "/oas-telemetry-ui" // path to the UI, e.g. "/oas-telemetry-ui" WARN: This must match the UI package's App.tsx "oas-telemetry-ui" path
+  },
+  auth: {
+    enabled: false,
+    apiKeyMaxAge: 1000 * 60 * 60,
+    // 1 hour
+    password: "oas-telemetry-password",
+    jwtSecret: "oas-telemetry-secret"
+  },
+  ai: {
+    openAIKey: null,
+    openAIModel: "gpt-3.5-turbo",
+    extraContextPrompts: [] // e.g. ["Provide detailed explanations", "Use simple language"]
+  },
+  traces: {
+    extraExporters: [],
+    // e.g. [new ConsoleSpanExporter()]
+    extraProcessors: [],
+    // e.g. [new SimpleSpanProcessor(new ConsoleSpanExporter())]
+    mainProcessorOptions: {
+      config: undefined
+    },
+    memoryExporter: {
+      enabled: true,
+      // auto start exporting.
+      retentionTimeSeconds: 60 * 60 // 1 hour
+    },
+    filters: [] // future feature, currently not used
+  },
+  metrics: {
+    mainMetricReaderOptions: {
+      exportIntervalMillis: 1000 * 60,
+      // 60 seconds
+      metricProducers: [] // experimental by OpenTelemetry, not used by OAS-TLM yet
+    },
+    extraReaders: [],
+    // e.g. [new PrometheusExporter()]
+    extraViews: [],
+    // e.g. [new MetricView({ name: 'my_metric', labels: ['env'] })]
+    memoryExporter: {
+      enabled: true,
+      retentionTimeSeconds: 60 * 60 // 1 hour
+    },
+    filters: [] // future feature, currently not used
+  },
+  logs: {
+    extraExporters: [],
+    // e.g. [new ConsoleLogRecordExporter()]
+    extraProcessors: [],
+    // e.g. [new SimpleLogRecordProcessor(new ConsoleLogRecordExporter())]
+    memoryExporter: {
+      enabled: true,
+      retentionTimeSeconds: 60 * 60 // 1 hour
+    },
+    filters: [] // future feature, currently not used
+  },
+  plugins: {
+    enabled: true,
+    // future feature
+    extraPlugins: [] // future feature
+  }
+};
+// Helper to get an environment variable with optional transform
+const getParsedEnvVar = (envKey, transform) => {
+  const rawValue = process.env[envKey];
+  // Treat undefined and "" in env as undefined (skip)
+  if (rawValue === undefined || rawValue === "") return undefined;
+  if (typeof transform === 'function') {
+    return transform(rawValue);
+  }
+  return rawValue;
+};
+const getConfig = (userConfig, fallbackConfig = defaultConfig, envConfig = loadEnv()) => {
+  // environment variables OVERRIDE userConfig OVERRIDE fallbackConfig
+  return (0, _lodash.default)({}, fallbackConfig, userConfig, envConfig);
+};
+exports.getConfig = getConfig;

package/dist/cjs/config/config.types.cjs

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

package/dist/cjs/index.cjs

@@ -4,40 +4,34 @@ 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 _bootConfig = require("./config/bootConfig.cjs");
+require("./telemetry/initializeTelemetry.cjs");
 var _logger = _interopRequireDefault(require("./utils/logger.cjs"));
-var _tlmRoutes = require("./tlmRoutes.cjs");
+var _config = require("./config/config.cjs");
+var _express = require("express");
+var _routesManager = require("./routesManager.cjs");
+var _telemetryConfigurator = require("./telemetry/telemetryConfigurator.cjs");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+// Load environment variables before any other imports
+// Initialize OpenTelemetry instrumentation
+
 /**
- * Returns the Oas Telemetry middleware. The parameters are the same as `globalOasTlmConfig`.
+ * Returns the OAS-Telemetry middleware.
  * 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') {
+  // This environment variable cannot be set via the config object,
+  // as it is required to disable OpenTelemetry SDK initialization,
+  // which occurs during the first import at the top of this file.
+  if (_bootConfig.bootEnvVariables.OASTLM_BOOT_MODULE_DISABLED) {
     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);
+  const oasTlmConfig = (0, _config.getConfig)(oasTlmInputConfig);
+  _logger.default.info("BaseUrl: ", oasTlmConfig.general.baseUrl);
+  if (!oasTlmConfig.general.spec && !oasTlmConfig.general.specFileName) _logger.default.warn("No spec provided, endpoint filtering will not be available. Please provide either `spec` or `specFileName` in the configuration.");
+  (0, _telemetryConfigurator.configureTelemetry)(oasTlmConfig);
+  (0, _routesManager.configureRoutes)(router, oasTlmConfig);
   return router;
 }
 module.exports = exports.default;

package/dist/cjs/{tlmRoutes.cjs → routesManager.cjs}

@@ -7,19 +7,20 @@ 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 _traceRoutes = require("./tlm-trace/traceRoutes.cjs");
+var _metricsRoutes = require("./tlm-metric/metricsRoutes.cjs");
+var _logRoutes = require("./tlm-log/logRoutes.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 _authRoutes = require("./tlm-auth/authRoutes.cjs");
+var _uiRoutes = require("./tlm-ui/uiRoutes.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"));
+var _utilRoutes = require("./tlm-util/utilRoutes.cjs");
+var _aiRoutes = require("./tlm-ai/aiRoutes.cjs");
+var _bootConfig = require("./config/bootConfig.cjs");
+var _pluginRoutes = require("./tlm-plugin/pluginRoutes.cjs");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-const configureRoutes = router => {
-  if (process.env.OASTLM_ENV === 'development') {
+const configureRoutes = (router, oasTlmConfig) => {
+  if (_bootConfig.bootEnvVariables.OASTLM_BOOT_ENV === 'development') {
     _logger.default.info("Running in development mode, enabling CORS for all origins");
     router.use((0, _cors.default)({
       origin: '*',
@@ -36,19 +37,25 @@ const configureRoutes = router => {
       limit: '10mb'
     })(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);
+  const allAuthMiddlewares = getWrappedMiddlewares(() => oasTlmConfig.auth.enabled, [(0, _cookieParser.default)(), (0, _authRoutes.getAuthRoutes)(oasTlmConfig), (0, _authMiddleware.getAuthMiddleware)(oasTlmConfig)]);
+  const baseUrl = oasTlmConfig.general.baseUrl;
+  router.use(baseUrl, allAuthMiddlewares);
+  router.use(baseUrl + "/traces", (0, _traceRoutes.getTraceRoutes)());
+  router.use(baseUrl + "/metrics", (0, _metricsRoutes.getMetricsRoutes)());
+  router.use(baseUrl + "/logs", (0, _logRoutes.getLogRoutes)());
+  router.use(baseUrl + "/ai", getWrappedMiddlewares(() => oasTlmConfig.ai.openAIKey !== null, [(0, _aiRoutes.getAIRoutes)(oasTlmConfig)]));
   // 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);
+  router.use(baseUrl + "/oas-telemetry-ui", (0, _uiRoutes.getUIRoutes)());
+  router.use(baseUrl + "/utils", (0, _utilRoutes.getUtilsRoutes)(oasTlmConfig));
+  router.use(baseUrl + "/plugins", (0, _pluginRoutes.getPluginRoutes)());
+  router.get(baseUrl + '/health', (_req, res) => {
+    res.status(200).send({
+      status: 'OK'
+    });
+  });
   //redirect to the UI when accessing the base URL
-  router.get(baseURL, (req, res) => {
-    res.redirect(baseURL + "/oas-telemetry-ui");
+  router.get(baseUrl, (req, res) => {
+    res.redirect(baseUrl + "/oas-telemetry-ui");
   });
 };
 /**

package/dist/cjs/{exporters/InMemoryLogRecordExporter.cjs → telemetry/custom-implementations/exporters/InMemoryDbLogExporter.cjs}

@@ -3,21 +3,30 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.InMemoryLogRecordExporter = void 0;
+exports.InMemoryDbLogExporter = 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"));
+var _circular = require("../utils/circular.cjs");
+var _wrappers = require("../wrappers.cjs");
+var _logger = _interopRequireDefault(require("../../../utils/logger.cjs"));
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-class InMemoryLogRecordExporter {
-  constructor() {
-    this._db = new _nedb.default();
+class InMemoryDbLogExporter extends _wrappers.Enabler {
+  constructor(retentionTimeInSeconds = 3600) {
+    super();
+    this._retentionTimeInSeconds = retentionTimeInSeconds;
+    this._db = new _nedb.default({
+      timestampData: true
+    });
+    this._db.ensureIndex({
+      fieldName: 'createdAt'
+    });
     this._miniSearch = new _minisearch.default({
       fields: ['body'],
       storeFields: ['_id'],
       idField: '_id'
     });
-    this._stopped = false;
+    this._startCleanupJob();
   }
   /*
   * SUPER WARNING:
@@ -31,7 +40,7 @@ class InMemoryLogRecordExporter {
    * @param resultCallback
    */
   export(logs, resultCallback) {
-    if (this._stopped) {
+    if (!this.isEnabled()) {
       resultCallback({
         code: _core.ExportResultCode.SUCCESS
       });
@@ -65,7 +74,7 @@ class InMemoryLogRecordExporter {
     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}"`, {
+      _logger.default.debug(`MiniSearch found ${ids.length} results for search term "${messageSearch}"`, {
         depth: 3
       });
       // Add MiniSearch results to the query
@@ -80,7 +89,7 @@ class InMemoryLogRecordExporter {
       if (result.code === _core.ExportResultCode.SUCCESS) {
         this._db.find({}, (err, docs) => {
           if (err) {
-            console.dir(err);
+            _logger.default.debug(err);
             callback(err, []);
             return;
           }
@@ -91,15 +100,6 @@ class InMemoryLogRecordExporter {
       }
     });
   }
-  start() {
-    this._stopped = false;
-  }
-  stop() {
-    this._stopped = true;
-  }
-  isRunning() {
-    return !this._stopped;
-  }
   getFinishedLogs() {
     return this._db.getAllData();
   }
@@ -125,6 +125,10 @@ class InMemoryLogRecordExporter {
       attributes: logRecord.attributes
     };
   }
+  set retentionTimeInSeconds(retentionTimeInSeconds) {
+    this._retentionTimeInSeconds = retentionTimeInSeconds;
+    _logger.default.info(`InMemoryDbLogExporter retention time set to ${this._retentionTimeInSeconds} seconds`);
+  }
   _insertLogs(logsToInsert, resultCallback) {
     this._db.insert(logsToInsert, (err, newDocs) => {
       if (err) {
@@ -142,5 +146,24 @@ class InMemoryLogRecordExporter {
     });
     return;
   }
+  _startCleanupJob() {
+    const interval = 1000;
+    setInterval(() => {
+      const expirationDate = new Date(Date.now() - this._retentionTimeInSeconds * 1000);
+      this._db.remove({
+        createdAt: {
+          $lt: expirationDate
+        }
+      }, {
+        multi: true
+      }, (err, numRemoved) => {
+        if (err) {
+          _logger.default.error('Error in TTL cleanup:', err);
+        } else if (numRemoved > 0) {
+          _logger.default.debug(`TTL cleanup: removed ${numRemoved} expired logs`);
+        }
+      });
+    }, interval);
+  }
 }
-exports.InMemoryLogRecordExporter = InMemoryLogRecordExporter;
+exports.InMemoryDbLogExporter = InMemoryDbLogExporter;

package/dist/cjs/telemetry/custom-implementations/exporters/InMemoryDbMetricExporter.cjs

@@ -0,0 +1,97 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.InMemoryDbMetricExporter = void 0;
+var _core = require("@opentelemetry/core");
+var _nedb = _interopRequireDefault(require("@seald-io/nedb"));
+var _circular = require("../utils/circular.cjs");
+var _wrappers = require("../wrappers.cjs");
+var _logger = _interopRequireDefault(require("../../../utils/logger.cjs"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class InMemoryDbMetricExporter extends _wrappers.Enabler {
+  constructor(retentionTimeInSeconds = 3600) {
+    super();
+    this._retentionTimeInSeconds = retentionTimeInSeconds;
+    this._metrics = new _nedb.default({
+      timestampData: true
+    });
+    this._metrics.ensureIndex({
+      fieldName: 'createdAt'
+    });
+    this._startCleanupJob();
+  }
+  export(metrics, resultCallback) {
+    try {
+      if (this.isEnabled()) {
+        const scopeMetrics = metrics?.scopeMetrics;
+        const cleanMetrics = (0, _circular.applyNesting)(scopeMetrics);
+        this._metrics.insert(cleanMetrics, (err, _newDoc) => {
+          if (err) {
+            _logger.default.error('Insertion Error:', err);
+            return;
+          }
+        });
+      }
+      setTimeout(() => resultCallback({
+        code: _core.ExportResultCode.SUCCESS
+      }), 0);
+    } catch (error) {
+      _logger.default.error('Error exporting metrics\n' + error.message + '\n' + error.stack);
+      return resultCallback({
+        code: _core.ExportResultCode.FAILED,
+        error: new Error('Error exporting metrics\n' + error.message + '\n' + error.stack)
+      });
+    }
+  }
+  shutdown() {
+    this._enabled = false;
+    this._metrics = new _nedb.default();
+    return this.forceFlush();
+  }
+  forceFlush() {
+    return Promise.resolve();
+  }
+  find(search, callback) {
+    this._metrics.find(search, callback);
+  }
+  reset() {
+    this._metrics = new _nedb.default();
+  }
+  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);
+  }
+  set retentionTimeInSeconds(retentionTimeInSeconds) {
+    this._retentionTimeInSeconds = retentionTimeInSeconds;
+    _logger.default.info(`InMemoryDbMetricExporter retention time set to ${this._retentionTimeInSeconds} seconds`);
+  }
+  _startCleanupJob() {
+    const interval = 1000;
+    setInterval(() => {
+      const expirationDate = new Date(Date.now() - this._retentionTimeInSeconds * 1000);
+      this._metrics.remove({
+        createdAt: {
+          $lt: expirationDate
+        }
+      }, {
+        multi: true
+      }, (err, numRemoved) => {
+        if (err) {
+          _logger.default.error('Error in TTL cleanup:', err);
+        } else if (numRemoved > 0) {
+          _logger.default.debug(`TTL cleanup: removed ${numRemoved} expired metrics`);
+        }
+      });
+    }, interval);
+  }
+}
+exports.InMemoryDbMetricExporter = InMemoryDbMetricExporter;

package/dist/cjs/telemetry/custom-implementations/exporters/InMemoryDbSpanExporter.cjs

@@ -0,0 +1,118 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.InMemoryDbSpanExporter = 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");
+var _wrappers = require("../wrappers.cjs");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class InMemoryDbSpanExporter extends _wrappers.Enabler {
+  constructor(retentionTimeInSeconds = 3600) {
+    super();
+    this._baseUrl = '/telemetry'; // Default base URL, can be overridden by the config
+    this._retentionTimeInSeconds = retentionTimeInSeconds;
+    this._spans = new _nedb.default({
+      timestampData: true
+    });
+    this._spans.ensureIndex({
+      fieldName: 'createdAt'
+    });
+    this._startCleanupJob();
+  }
+  set baseUrl(baseUrl) {
+    this._baseUrl = baseUrl;
+  }
+  set retentionTimeInSeconds(retentionTimeInSeconds) {
+    this._retentionTimeInSeconds = retentionTimeInSeconds;
+    _logger.default.info(`InMemoryDbSpanExporter retention time set to ${this._retentionTimeInSeconds} seconds`);
+  }
+  export(readableSpans, resultCallback) {
+    _logger.default.debug('InMemoryDbSpanExporter.export called with spans: ', readableSpans.length);
+    try {
+      if (!this.isEnabled()) {
+        _logger.default.debug('InMemoryDbSpanExporter is not enabled. Skipping export.');
+        return resultCallback({
+          code: _core.ExportResultCode.SUCCESS
+        });
+      }
+      // 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 => {
+        const target = span?.attributes?.http?.target; // Exclude spans where target includes 'telemetry' but NOT 'telemetry/utils'
+        if (target && target.includes(this._baseUrl)) {
+          return target.includes(this._baseUrl + '/utils');
+        }
+        return true;
+      });
+      // Insert spans into the in-memory database
+      this._spans.insert(cleanSpans, (err, _newDoc) => {
+        if (err) {
+          _logger.default.error(err);
+          return;
+        }
+      });
+      setTimeout(() => resultCallback({
+        code: _core.ExportResultCode.SUCCESS
+      }), 0);
+    } catch (error) {
+      _logger.default.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)
+      });
+    }
+  }
+  shutdown() {
+    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();
+  }
+  /**
+   * 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);
+  }
+  _startCleanupJob() {
+    const interval = 1000;
+    setInterval(() => {
+      const expirationDate = new Date(Date.now() - this._retentionTimeInSeconds * 1000);
+      this._spans.remove({
+        createdAt: {
+          $lt: expirationDate
+        }
+      }, {
+        multi: true
+      }, (err, numRemoved) => {
+        if (err) {
+          _logger.default.error('Error in TTL cleanup:', err);
+        } else if (numRemoved > 0) {
+          _logger.default.debug(`TTL cleanup: removed ${numRemoved} expired spans`);
+        }
+      });
+    }, interval);
+  }
+}
+exports.InMemoryDbSpanExporter = InMemoryDbSpanExporter;