@oas-tools/oas-telemetry 0.3.0 → 0.5.0

package/dist/exporters/InMemoryDbExporter.cjs

@@ -17,6 +17,8 @@ if (process.env.OTDEBUG == "true") dbglog = console.log;
 
 class InMemoryExporter {
   constructor() {
+    // Overrided by dynamic exporter
+    _defineProperty(this, "plugins", []);
     this._spans = new _nedb.default();
     this._stopped = true;
   }
@@ -27,15 +29,15 @@ class InMemoryExporter {
         const cleanSpans = readableSpans.map(nestedSpan => removeCircularRefs(nestedSpan)) // to avoid JSON parsing error
         .map(span => applyNesting(span)) // to avoid dot notation in keys (neDB does not support dot notation in keys)
         .filter(span => !span.attributes?.http?.target?.includes("/telemetry")); // to avoid telemetry spans
-
         // Insert spans into the in-memory database
         this._spans.insert(cleanSpans, (err, newDoc) => {
-          InMemoryExporter.plugins.forEach((p, i) => {
+          // p = {name, plugin
+          this.plugins.forEach((pluginResource, i) => {
             cleanSpans.forEach(t => {
-              dbglog(`Sending trace <${t._id}> to plugin (Plugin #${i}) <${p.name}>`);
+              dbglog(`Sending trace <${t._id}> to plugin (Plugin #${i}) <${pluginResource.name}>`);
               dbglog(`Trace: \n<${JSON.stringify(t, null, 2)}`);
               //TODO: This should be called newSpan instead of newTrace
-              p.newTrace(t);
+              pluginResource.plugin.newTrace(t);
             });
           });
           if (err) {
@@ -61,31 +63,32 @@ class InMemoryExporter {
   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
+  /**
+   * 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;
-  }
-  activatePlugin(plugin) {
-    dbglog(`Activating plugin <${plugin.getName()}>...`);
-    InMemoryExporter.plugins.push(plugin);
-    dbglog(`Plugin <${plugin.getName()}> active (Total active plugins: ${InMemoryExporter.plugins.length})`);
+    return this._spans.getAllData();
   }
 }
 exports.InMemoryExporter = InMemoryExporter;
-_defineProperty(InMemoryExporter, "plugins", []);
 function removeCircularRefs(obj) {
   const seen = new WeakMap(); // Used to keep track of visited objects
 
@@ -111,30 +114,30 @@ function removeCircularRefs(obj) {
   return JSON.parse(jsonString);
 }
 
-/**
- * Recursively converts dot-separated keys in an object to nested objects.
- * 
- * @param {Object} obj - The object to process.
- * @returns {Object} - 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"
- * //     }
- * //   }
- * // }
+/**
+ * Recursively converts dot-separated keys in an object to nested objects.
+ * 
+ * @param {Object} obj - The object to process.
+ * @returns {Object} - 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 = {};
@@ -158,11 +161,11 @@ function convertToNestedObject(obj) {
   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.
+/**
+ * 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) {
   // Recursively apply convertToNestedObject to each level of the object

package/dist/exporters/consoleExporter.cjs

@@ -0,0 +1,52 @@
+"use strict";
+
+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", []);
+  }
+  // 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 [];
+  }
+}
+exports.ConsoleExporter = ConsoleExporter;

package/dist/exporters/dynamicExporter.cjs

@@ -0,0 +1,64 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+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.
+ */
+class DynamicExporter {
+  /** 
+   * @returns {Array<PluginResource>} 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}
+   */
+  pushPlugin(pluginResource) {
+    if (!this.exporter.plugins) {
+      this.exporter.plugins = [];
+    }
+    this.exporter.plugins.push(pluginResource);
+  }
+  activatePlugin(pluginId) {
+    let plugins = this.exporter.plugins;
+    if (plugins) {
+      // plugin.active = true;
+      plugins.forEach(plugin => {
+        if (plugin.id === pluginId) {
+          plugin.active = true;
+        }
+      });
+    }
+  }
+  constructor() {
+    _defineProperty(this, "exporter", void 0);
+    let defaultExporter = new _consoleExporter.ConsoleExporter();
+    this.exporter = defaultExporter;
+    this.export = (readableSpans, resultCallback) => defaultExporter.export(readableSpans, resultCallback);
+    this.shutdown = () => defaultExporter.shutdown();
+    this.forceFlush = () => defaultExporter.forceFlush();
+  }
+  changeExporter(newExporter) {
+    this.exporter = newExporter;
+    // OpenTelemetry methods
+    this.export = (readableSpans, resultCallback) => newExporter.export(readableSpans, resultCallback);
+    this.shutdown = () => newExporter.shutdown();
+    this.forceFlush = () => newExporter.forceFlush();
+    // Other methods should be called directly from the exporter: globalOasTlmConfig.dynamicExporter.exporter.method()
+  }
+}
+exports.DynamicExporter = DynamicExporter;
+var _default = exports.default = DynamicExporter;

package/dist/index.cjs

@@ -4,264 +4,77 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = oasTelemetry;
-var _telemetry = require("./telemetry.cjs");
+require("./openTelemetry.cjs");
+var _config = require("./config.cjs");
+var _cookieParser = _interopRequireDefault(require("cookie-parser"));
 var _express = require("express");
-var _v = _interopRequireDefault(require("v8"));
-var _fs = require("fs");
-var _path = _interopRequireDefault(require("path"));
-var _jsYaml = _interopRequireDefault(require("js-yaml"));
-var _ui = _interopRequireDefault(require("./ui.cjs"));
-var _axios = _interopRequireDefault(require("axios"));
-var _importFromString = require("import-from-string");
+var _authMiddleware = require("./middleware/authMiddleware.cjs");
+var _authRoutes = _interopRequireDefault(require("./routes/authRoutes.cjs"));
+var _telemetryRoutes = require("./routes/telemetryRoutes.cjs");
+var _InMemoryDbExporter = require("./exporters/InMemoryDbExporter.cjs");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-// telemetryMiddleware.js
-
 let dbglog = () => {};
 if (process.env.OTDEBUG == "true") dbglog = console.log;
-let plugins = [];
-let telemetryStatus = {
-  active: true
-};
-let baseURL = '/telemetry';
-let telemetryConfig = {
-  exporter: _telemetry.inMemoryExporter,
-  specFileName: ""
-};
-function oasTelemetry(tlConfig) {
-  if (tlConfig) {
-    dbglog('Telemetry config provided');
-    telemetryConfig = tlConfig;
-    if (telemetryConfig.exporter == undefined) telemetryConfig.exporter = _telemetry.inMemoryExporter;
+
+/**
+ * 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.
+ * 
+ * @param {Object} OasTlmConfig Configuration object.
+ * @param {string} [OasTlmConfig.baseURL="/telemetry"] The base URL for the telemetry routes.
+ * @param {Object} [OasTlmConfig.spec] The OpenAPI spec object.
+ * @param {string} [OasTlmConfig.specFileName] Alternative to `spec`: the path to the OpenAPI spec file.
+ * @param {boolean} [OasTlmConfig.autoActivate=true] Whether to start telemetry automatically on load.
+ * @param {number} [OasTlmConfig.apiKeyMaxAge=1800000] The maximum age of the API key in milliseconds.
+ * @param {string} [OasTlmConfig.defaultApiKey] The default API key to use.
+ * @param {OasTlmExporter} [OasTlmConfig.exporter=InMemoryExporter] The exporter to use. Must implement the `OasTlmExporter` interface.
+ * @returns {Router} The middleware router for Oas Telemetry.
+ */
+function oasTelemetry(OasTlmConfig) {
+  const router = (0, _express.Router)();
+  if (process.env.OASTLM_MODULE_DISABLED === 'true') {
+    return router;
   }
-  if (telemetryConfig.spec) dbglog(`Spec content provided`);else {
-    if (telemetryConfig.specFileName != "") dbglog(`Spec file used for telemetry: ${telemetryConfig.specFileName}`);else {
+  ;
+  if (OasTlmConfig) {
+    console.log("User provided config");
+    // Global = user-provided || default, for each key
+    for (const key in _config.globalOasTlmConfig) {
+      _config.globalOasTlmConfig[key] = OasTlmConfig[key] ?? _config.globalOasTlmConfig[key];
+    }
+  }
+  console.log("baseURL: ", _config.globalOasTlmConfig.baseURL);
+  _config.globalOasTlmConfig.dynamicExporter.changeExporter(OasTlmConfig.exporter ?? new _InMemoryDbExporter.InMemoryExporter());
+  if (_config.globalOasTlmConfig.spec) dbglog(`Spec content provided`);else {
+    if (_config.globalOasTlmConfig.specFileName != "") dbglog(`Spec file used for telemetry: ${_config.globalOasTlmConfig.specFileName}`);else {
       console.error("No spec available !");
     }
   }
-  const router = (0, _express.Router)();
-  if (telemetryConfig.baseURL) baseURL = telemetryConfig.baseURL;
+  router.use((0, _cookieParser.default)());
+  const baseURL = _config.globalOasTlmConfig.baseURL;
   router.use((0, _express.json)());
-  router.get(baseURL, mainPage);
-  router.get(baseURL + "/detail/*", detailPage);
-  router.get(baseURL + "/spec", specLoader);
-  router.get(baseURL + "/api", apiPage);
-  router.get(baseURL + "/start", startTelemetry);
-  router.get(baseURL + "/stop", stopTelemetry);
-  router.get(baseURL + "/status", statusTelemetry);
-  router.get(baseURL + "/reset", resetTelemetry);
-  router.get(baseURL + "/list", listTelemetry);
-  router.post(baseURL + "/find", findTelemetry);
-  router.get(baseURL + "/heapStats", heapStats);
-  router.get(baseURL + "/plugins", listPlugins);
-  router.post(baseURL + "/plugins", registerPlugin);
+  router.use(baseURL, _authRoutes.default);
+  router.use(baseURL, _authMiddleware.authMiddleware); // Add the auth middleware
+  router.use(baseURL, _telemetryRoutes.telemetryRoutes);
+  if (_config.globalOasTlmConfig.autoActivate) {
+    _config.globalOasTlmConfig.dynamicExporter.exporter?.start();
+  }
   return router;
 }
-const apiPage = (req, res) => {
-  let text = `
-    <h1>Telemetry API routes:</h1>
-    <ul>
-        <li><a href="/telemetry/start">/telemetry/start</a></li>
-        <li><a href="/telemetry/stop">/telemetry/stop</a></li>
-        <li><a href="/telemetry/status">/telemetry/status</a></li>
-        <li><a href="/telemetry/reset">/telemetry/reset</a></li>
-        <li><a href="/telemetry/list">/telemetry/list</a></li>
-        <li><a href="/telemetry/heapStats">/telemetry/heapStats</a></li>
-        <li>/telemetry/find [POST]</li>
-    </ul>
-    `;
-  res.send(text);
-};
-const mainPage = (req, res) => {
-  res.set('Content-Type', 'text/html');
-  res.send((0, _ui.default)().main);
-};
-const detailPage = (req, res) => {
-  res.set('Content-Type', 'text/html');
-  res.send((0, _ui.default)().detail);
-};
-const specLoader = (req, res) => {
-  if (telemetryConfig.specFileName) {
-    try {
-      const data = (0, _fs.readFileSync)(telemetryConfig.specFileName, {
-        encoding: 'utf8',
-        flag: 'r'
-      });
-      const extension = _path.default.extname(telemetryConfig.specFileName);
-      let json = data;
-      if (extension == _jsYaml.default) json = JSON.stringify(_jsYaml.default.SafeLoad(data), null, 2);
-      res.setHeader('Content-Type', 'application/json');
-      res.send(json);
-    } catch (e) {
-      console.error(`ERROR loading spec file ${telemetryConfig.specFileName}: ${e}`);
-    }
-  } else {
-    if (telemetryConfig.spec) {
-      let spec = false;
-      try {
-        spec = JSON.parse(telemetryConfig.spec);
-      } catch (ej) {
-        try {
-          spec = JSON.stringify(_jsYaml.default.load(telemetryConfig.spec), null, 2);
-        } catch (ey) {
-          console.error(`Error parsing spec: ${ej} - ${ey}`);
-        }
-      }
-      if (!spec) {
-        res.status(404);
-      } else {
-        res.setHeader('Content-Type', 'application/json');
-        res.send(spec);
-      }
-    }
-  }
-};
-const startTelemetry = (req, res) => {
-  telemetryConfig.exporter.start();
-  res.send('Telemetry started');
-};
-const stopTelemetry = (req, res) => {
-  telemetryConfig.exporter.stop();
-  res.send('Telemetry stopped');
-};
-const statusTelemetry = (req, res) => {
-  const status = !telemetryConfig.exporter._stopped || false;
-  res.send({
-    active: status
-  });
-};
-const resetTelemetry = (req, res) => {
-  telemetryConfig.exporter.reset();
-  res.send('Telemetry reset');
-};
-const listTelemetry = (req, res) => {
-  const spansDB = telemetryConfig.exporter.getFinishedSpans();
-  spansDB.find({}, (err, docs) => {
-    if (err) {
-      console.error(err);
-      return;
-    }
-    const spans = docs;
-    res.send({
-      spansCount: spans.length,
-      spans: spans
-    });
-  });
-};
-const heapStats = (req, res) => {
-  var heapStats = _v.default.getHeapStatistics();
 
-  // Round stats to MB
-  var roundedHeapStats = Object.getOwnPropertyNames(heapStats).reduce(function (map, stat) {
-    map[stat] = Math.round(heapStats[stat] / 1024 / 1024 * 1000) / 1000;
-    return map;
-  }, {});
-  roundedHeapStats['units'] = 'MB';
-  res.send(roundedHeapStats);
-};
-const findTelemetry = (req, res) => {
-  const spansDB = telemetryConfig.exporter.getFinishedSpans();
-  const body = req.body;
-  const search = body?.search ? body.search : {};
-  if (body?.flags?.containsRegex) {
-    try {
-      body.config?.regexIds?.forEach(regexId => {
-        search[regexId] = new RegExp(search[regexId]);
-      });
-    } catch (e) {
-      console.error(e);
-      res.status(404).send({
-        spansCount: 0,
-        spans: [],
-        error: e
-      });
-      return;
-    }
-    spansDB.find(search, (err, docs) => {
-      if (err) {
-        console.error(err);
-        res.status(404).send({
-          spansCount: 0,
-          spans: [],
-          error: err
-        });
-        return;
-      }
-      const spans = docs;
-      res.send({
-        spansCount: spans.length,
-        spans: spans
-      });
-    });
-  }
-};
-const listPlugins = (req, res) => {
-  res.send(plugins.map(p => {
-    return {
-      id: p.id,
-      url: p.url,
-      active: p.active
-    };
-  }));
-};
-const registerPlugin = async (req, res) => {
-  let pluginResource = req.body;
-  dbglog(`Plugin Registration Request: = ${JSON.stringify(req.body, null, 2)}...`);
-  dbglog(`Getting plugin at ${pluginResource.url}...`);
-  let pluginCode;
-  if (!pluginResource.url && !pluginResource.code) {
-    res.status(400).send(`Plugin code or URL must be provided`);
-    return;
-  }
-  let module;
-  try {
-    if (pluginResource.code) {
-      pluginCode = pluginResource.code;
-    } else {
-      const response = await _axios.default.get(pluginResource.url);
-      pluginCode = response.data;
-    }
-    if (!pluginCode) {
-      res.status(400).send(`Plugin code could not be loaded`);
-      return;
-    }
-    dbglog("Plugin size: " + pluginCode?.length);
-    if (pluginResource?.moduleFormat && pluginResource.moduleFormat.toUpperCase() == "ESM") {
-      console.log("ESM detected");
-      module = await (0, _importFromString.importFromString)(pluginCode);
-    } else {
-      console.log("CJS detected (default)");
-      module = await (0, _importFromString.requireFromString)(pluginCode);
-      console.log(module);
-    }
-  } catch (error) {
-    console.error(`Error loading plugin: ${error}`);
-    res.status(400).send(`Error loading plugin: ${error}`);
-    return;
-  }
-  if (module.plugin == undefined) {
-    res.status(400).send(`Plugin code should export a "plugin" object`);
-    console.log("Error in plugin code: no plugin object exported");
-    return;
-  }
-  for (let requiredFunction of ["load", "getName", "isConfigured"]) {
-    if (module.plugin[requiredFunction] == undefined) {
-      res.status(400).send(`The plugin code exports a "plugin" object, however it should have a "${requiredFunction}" method`);
-      console.log("Error in plugin code: some required functions are missing");
-      return;
-    }
-  }
-  let plugin = module.plugin;
-  if (plugin.isConfigured()) {
-    dbglog(`Loaded plugin <${plugin.getName()}>`);
-    pluginResource.plugin = plugin;
-    pluginResource.name = plugin.getName();
-    pluginResource.active = true;
-    plugins.push(pluginResource);
-    _telemetry.inMemoryExporter.activatePlugin(pluginResource.plugin);
-    res.status(201).send(`Plugin registered`);
-  } else {
-    console.error(`Plugin <${plugin.getName()}> can not be configured`);
-    res.status(400).send(`Plugin configuration problem`);
-  }
-};
+/**
+ * @typedef OasTlmExporter
+ * Represents an exporter that processes and manages telemetry data.
+ * Any custom exporter must implement these methods.
+ * 
+ * @method {void} start() Starts the exporter, allowing it to process data.
+ * @method {void} stop() Stops the exporter and halts data processing.
+ * @method {void} reset() Resets the internal state of the exporter (e.g., clears buffers or data stores).
+ * @method {boolean} isRunning() Returns whether the exporter is actively processing data.
+ * @method {Array} getFinishedSpans() Retrieves the collected spans from the exporter.
+ * @method {any} export(ReadableSpan, SpanExporterResultCallback) Exports spans.
+ * @method {Promise<void>} shutdown() Gracefully shuts down the exporter, flushing data if necessary.
+ * @method {Promise<void>} forceFlush() Exports any pending data that has not yet been processed.
+ * @property {Array} plugins An array of plugins that can be activated by the exporter.
+ */
 module.exports = exports.default;

package/dist/middleware/auth.cjs

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = auth;
+function auth(req, res, next) {
+  const apiKey = req.query.apiKey || req.body.apiKey;
+  if (apiKey === process.env.APIKEY) {
+    next();
+  } else {
+    res.status(401).send({
+      valid: false
+    });
+  }
+}
+module.exports = exports.default;

package/dist/middleware/authMiddleware.cjs

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.authMiddleware = authMiddleware;
+var _config = require("../config.cjs");
+var _jsonwebtoken = _interopRequireDefault(require("jsonwebtoken"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function authMiddleware(req, res, next) {
+  const apiKey = req.cookies.apiKey;
+  if (apiKey) {
+    const decoded = _jsonwebtoken.default.verify(apiKey, _config.globalOasTlmConfig.jwtSecret);
+    if (decoded.password === _config.globalOasTlmConfig.password) {
+      return next();
+    }
+  }
+  res.status(401).redirect(_config.globalOasTlmConfig.baseURL + '/login');
+}

package/dist/openTelemetry.cjs

@@ -0,0 +1,20 @@
+"use strict";
+
+var _sdkNode = require("@opentelemetry/sdk-node");
+var _resources = require("@opentelemetry/resources");
+var _instrumentationHttp = require("@opentelemetry/instrumentation-http");
+var _config = require("./config.cjs");
+// import { getNodeAutoInstrumentations } from '@opentelemetry/auto-instrumentations-node';
+
+// DynamicExporter allows changing to any exporter at runtime;
+const traceExporter = _config.globalOasTlmConfig.dynamicExporter;
+const sdk = new _sdkNode.NodeSDK({
+  resource: new _resources.Resource({
+    service: 'oas-telemetry-service'
+  }),
+  traceExporter,
+  instrumentations: [new _instrumentationHttp.HttpInstrumentation()]
+});
+if (process.env.OASTLM_MODULE_DISABLED !== 'true') {
+  sdk.start();
+}