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

package/dist/cjs/routesManager.cjs

@@ -23,13 +23,21 @@ 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: '*',
-      // Permitir todas las solicitudes en desarrollo
-      methods: ['GET', 'POST', 'PUT', 'DELETE'],
-      allowedHeaders: ['Content-Type', 'Authorization']
+      origin: (origin, callback) => {
+        if (!origin || /^http:\/\/localhost:\d+$/.test(origin)) {
+          callback(null, true);
+        } else {
+          callback(new Error('Not allowed by CORS'));
+        }
+      },
+      credentials: true
     }));
   }
-  router.use((req, res, next) => {
+  const telemetryBaseUrl = oasTlmConfig.general.baseUrl;
+  // Sub-router for all telemetry endpoints
+  const telemetryRouter = (0, _express.Router)();
+  // Body parser for JSON requests
+  telemetryRouter.use((req, res, next) => {
     if (req.body !== undefined) {
       return next(); // Already parsed, no need to parse again.
     }
@@ -37,52 +45,32 @@ const configureRoutes = (router, oasTlmConfig) => {
       limit: '10mb'
     })(req, res, next);
   });
-  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 + "/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) => {
+  telemetryRouter.get('/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");
+  // Redirect to the UI when accessing the base URL
+  telemetryRouter.get('/', (req, res) => {
+    res.redirect(`${telemetryBaseUrl}/oas-telemetry-ui/`);
   });
+  // WARNING: This path must be the same as the one used in the UI package App.tsx "oas-telemetry-ui"
+  telemetryRouter.use("/oas-telemetry-ui", (0, _uiRoutes.getUIRoutes)());
+  telemetryRouter.use("/utils", (0, _utilRoutes.getUtilsRoutes)(oasTlmConfig));
+  // Auth routes must be registered. If authentication is not enabled, all requests will be allowed.
+  // Frontend will use these endpoints;
+  telemetryRouter.use((0, _cookieParser.default)());
+  // Refresh token uses /auth/refresh path, careful if you change it
+  telemetryRouter.use('/auth', (0, _authRoutes.getAuthRoutes)(oasTlmConfig));
+  telemetryRouter.use((0, _authMiddleware.getAuthMiddleware)(oasTlmConfig));
+  telemetryRouter.use("/traces", (0, _traceRoutes.getTraceRoutes)());
+  telemetryRouter.use("/metrics", (0, _metricsRoutes.getMetricsRoutes)());
+  telemetryRouter.use("/logs", (0, _logRoutes.getLogRoutes)());
+  if (oasTlmConfig.ai.openAIKey) {
+    telemetryRouter.use("/ai", (0, _aiRoutes.getAIRoutes)(oasTlmConfig));
+  }
+  telemetryRouter.use("/plugins", (0, _pluginRoutes.getPluginRoutes)());
+  // Mount the telemetryRouter under telemetryBaseUrl
+  router.use(telemetryBaseUrl, telemetryRouter);
 };
-/**
- * This function wraps the provided middleware functions with a condition callback.
- * If the condition callback returns true, the middleware/router will be executed.
- * If the condition callback returns false, the middleware/router will be skipped.
- *
- * @callback {function} conditionCallback A callback function that returns a boolean to determine if the middleware should be used.
- * @param {Array} middlewares An array of middleware or routers to be wrapped.
- * @returns {Array} An array of wrapped middleware functions.
- */
-exports.configureRoutes = configureRoutes;
-function getWrappedMiddlewares(conditionCallback, middlewares) {
-  return middlewares.map(middleware => {
-    return function (req, res, next) {
-      if (conditionCallback()) {
-        if (typeof middleware === 'function') {
-          // look for handle property, if it exists, it's a router. If not call middleware
-          if (middleware.handle) {
-            middleware.handle(req, res, next);
-          } else {
-            middleware(req, res, next);
-          }
-        }
-      } else {
-        next();
-      }
-    };
-  });
-}
+exports.configureRoutes = configureRoutes;

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

@@ -10,7 +10,13 @@ var _minisearch = _interopRequireDefault(require("minisearch"));
 var _circular = require("../utils/circular.cjs");
 var _wrappers = require("../wrappers.cjs");
 var _logger = _interopRequireDefault(require("../../../utils/logger.cjs"));
+var _pluginService = require("../../../tlm-plugin/pluginService.cjs");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+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 InMemoryDbLogExporter extends _wrappers.Enabler {
   constructor(retentionTimeInSeconds = 3600) {
     super();
@@ -40,12 +46,6 @@ class InMemoryDbLogExporter extends _wrappers.Enabler {
    * @param resultCallback
    */
   export(logs, resultCallback) {
-    if (!this.isEnabled()) {
-      resultCallback({
-        code: _core.ExportResultCode.SUCCESS
-      });
-      return;
-    }
     const logsToInsert = logs.map(logRecord => {
       // Remove circular references first, then apply nesting, then export info
       const formattedLog = this._formatLogRecord(logRecord);
@@ -53,7 +53,16 @@ class InMemoryDbLogExporter extends _wrappers.Enabler {
       const nestedLog = (0, _circular.applyNesting)(cleanedLog);
       return nestedLog;
     });
-    this._insertLogs(logsToInsert, resultCallback);
+    logsToInsert.forEach(log => {
+      _pluginService.pluginService.broadcastLog(log);
+    });
+    // ENABLED only affect storage not plugin broadcasting
+    if (this.isEnabled()) {
+      this._insertLogs(logsToInsert, resultCallback);
+    }
+    resultCallback({
+      code: _core.ExportResultCode.SUCCESS
+    });
   }
   reset() {
     this._db = new _nedb.default();
@@ -70,19 +79,36 @@ class InMemoryDbLogExporter extends _wrappers.Enabler {
     this._db = null;
     this._miniSearch = null;
   }
-  find(query, messageSearch, callback) {
+  async find(findConfig) {
+    const {
+      query,
+      messageSearch,
+      limit,
+      sortOrder
+    } = findConfig;
+    const finalQuery = _objectSpread({}, query);
+    const effectiveSortOrder = sortOrder || {
+      timestamp: -1
+    };
     if (messageSearch) {
-      const searchResults = this._miniSearch.search(messageSearch);
+      const searchResults = this._miniSearch.search(messageSearch, {
+        prefix: true,
+        fuzzy: 0.2
+      });
       const ids = searchResults.map(result => result._id);
       _logger.default.debug(`MiniSearch found ${ids.length} results for search term "${messageSearch}"`, {
         depth: 3
       });
-      // Add MiniSearch results to the query
-      query._id = {
+      finalQuery._id = {
         $in: ids
       };
     }
-    this._db.find(query, callback);
+    const docs = await new Promise((resolve, reject) => {
+      this._db.find(finalQuery).sort(effectiveSortOrder).limit(limit).exec((err, docs) => {
+        if (err) reject(err);else resolve(docs);
+      });
+    });
+    return docs;
   }
   insert(data, callback) {
     this._insertLogs(data, result => {
@@ -115,7 +141,8 @@ class InMemoryDbLogExporter extends _wrappers.Enabler {
         attributes: logRecord.resource.attributes
       },
       instrumentationScope: logRecord.instrumentationScope,
-      timestamp: (0, _core.hrTimeToMicroseconds)(logRecord.hrTime) || Date.now(),
+      timestamp: (0, _core.hrTimeToMicroseconds)(logRecord.hrTime) ?? Date.now(),
+      observedTimestamp: (0, _core.hrTimeToMicroseconds)(logRecord.hrTimeObserved) ?? Date.now(),
       traceId: logRecord.spanContext?.traceId,
       spanId: logRecord.spanContext?.spanId,
       traceFlags: logRecord.spanContext?.traceFlags,
@@ -129,6 +156,9 @@ class InMemoryDbLogExporter extends _wrappers.Enabler {
     this._retentionTimeInSeconds = retentionTimeInSeconds;
     _logger.default.info(`InMemoryDbLogExporter retention time set to ${this._retentionTimeInSeconds} seconds`);
   }
+  get retentionTimeInSeconds() {
+    return this._retentionTimeInSeconds;
+  }
   _insertLogs(logsToInsert, resultCallback) {
     this._db.insert(logsToInsert, (err, newDocs) => {
       if (err) {

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

@@ -9,6 +9,7 @@ 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"));
+var _pluginService = require("../../../tlm-plugin/pluginService.cjs");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 class InMemoryDbMetricExporter extends _wrappers.Enabler {
   constructor(retentionTimeInSeconds = 3600) {
@@ -24,9 +25,13 @@ class InMemoryDbMetricExporter extends _wrappers.Enabler {
   }
   export(metrics, resultCallback) {
     try {
+      const scopeMetrics = metrics?.scopeMetrics;
+      const cleanMetrics = (0, _circular.applyNesting)(scopeMetrics);
+      cleanMetrics.forEach(metric => {
+        _pluginService.pluginService.broadcastMetric(metric);
+      });
+      // Insert only if exporter is enabled
       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);
@@ -74,6 +79,9 @@ class InMemoryDbMetricExporter extends _wrappers.Enabler {
     this._retentionTimeInSeconds = retentionTimeInSeconds;
     _logger.default.info(`InMemoryDbMetricExporter retention time set to ${this._retentionTimeInSeconds} seconds`);
   }
+  get retentionTimeInSeconds() {
+    return this._retentionTimeInSeconds;
+  }
   _startCleanupJob() {
     const interval = 1000;
     setInterval(() => {

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

@@ -9,6 +9,7 @@ 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");
+var _pluginService = require("../../../tlm-plugin/pluginService.cjs");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 class InMemoryDbSpanExporter extends _wrappers.Enabler {
   constructor(retentionTimeInSeconds = 3600) {
@@ -30,35 +31,39 @@ class InMemoryDbSpanExporter extends _wrappers.Enabler {
     this._retentionTimeInSeconds = retentionTimeInSeconds;
     _logger.default.info(`InMemoryDbSpanExporter retention time set to ${this._retentionTimeInSeconds} seconds`);
   }
+  get retentionTimeInSeconds() {
+    return this._retentionTimeInSeconds;
+  }
   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'
+        const target = span?.attributes?.http?.target;
+        // Exclude spans where target includes 'telemetry' but NOT 'telemetry/utils/generate-log' or 'telemetry/utils/generate-wait'
         if (target && target.includes(this._baseUrl)) {
-          return target.includes(this._baseUrl + '/utils');
+          return target.includes("generate");
         }
         return true;
       });
-      // Insert spans into the in-memory database
-      this._spans.insert(cleanSpans, (err, _newDoc) => {
-        if (err) {
-          _logger.default.error(err);
-          return;
-        }
+      cleanSpans.forEach(span => {
+        _pluginService.pluginService.broadcastTrace(span);
       });
-      setTimeout(() => resultCallback({
+      // 
+      if (this.isEnabled()) {
+        // Insert spans into the in-memory database
+        this._spans.insert(cleanSpans, (err, _newDoc) => {
+          if (err) {
+            _logger.default.error(err);
+            return;
+          }
+        });
+      }
+      return resultCallback({
         code: _core.ExportResultCode.SUCCESS
-      }), 0);
+      });
     } catch (error) {
       _logger.default.error('Error exporting spans\n' + error.message + '\n' + error.stack);
       return resultCallback({

package/dist/cjs/telemetry/initializeTelemetry.cjs

@@ -8,6 +8,7 @@ var _sdkTraceNode = require("@opentelemetry/sdk-trace-node");
 var _apiLogs = require("@opentelemetry/api-logs");
 var _sdkLogs = require("@opentelemetry/sdk-logs");
 var _bootConfig = require("../config/bootConfig.cjs");
+var _util = _interopRequireDefault(require("util"));
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 // THIS INSTRUMENTATIONS NEED TO BE LOADED BEFORE ANYTHING ELSE
 // They use monkey-patching to instrument the HTTP server and client.
@@ -42,33 +43,56 @@ function initializeLogs() {
   });
   // Get a logger instance
   const loggerInstance = loggerProvider.getLogger('oas-telemetry'); // Use loggerProvider to get the logger
-  // Override console methods to emit logs via OpenTelemetry, like an instrumentation
-  const originalConsoleMethods = {
-    log: console.log,
-    warn: console.warn,
-    error: console.error,
-    info: console.info,
-    debug: console.debug
-  };
-  Object.keys(originalConsoleMethods).forEach(method => {
+  Object.keys(_telemetryRegistry.originalConsoleMethods).forEach(method => {
     // @ts-expect-error yes
     console[method] = (...args) => {
+      const severity = getSeverityForMethod(method);
       loggerInstance.emit({
-        severityNumber: _apiLogs.SeverityNumber[method.toUpperCase()] || _apiLogs.SeverityNumber.INFO,
-        severityText: method.toUpperCase(),
-        body: args.join(' '),
+        severityNumber: severity.number,
+        severityText: severity.text,
+        body: _util.default.format(...args),
         attributes: {
-          'source.source': `console.${method}`
+          'source': `console.${method}`,
+          "library": "oas-telemetry"
         }
       });
       // @ts-expect-error yes
-      originalConsoleMethods[method](...args);
+      _telemetryRegistry.originalConsoleMethods[method](...args);
     };
   });
 }
 function initializeMetrics() {
   _logger.default.info('📈 Initializing MeterProvider');
-  // WARN: This is a custom provider that allows adding readers dynamically at runtime.
   // WARN: Default PeriodicExportingMetricReader is added post initialization (see telemetryConfigurator.ts)
   // The in memory exporter is added by default to that reader. More readers are allowed to be added dynamically
+}
+function getSeverityForMethod(method) {
+  switch (method) {
+    case "log":
+    case "info":
+      return {
+        number: _apiLogs.SeverityNumber.INFO,
+        text: "INFO"
+      };
+    case "debug":
+      return {
+        number: _apiLogs.SeverityNumber.DEBUG,
+        text: "DEBUG"
+      };
+    case "warn":
+      return {
+        number: _apiLogs.SeverityNumber.WARN,
+        text: "WARN"
+      };
+    case "error":
+      return {
+        number: _apiLogs.SeverityNumber.ERROR,
+        text: "ERROR"
+      };
+    default:
+      return {
+        number: _apiLogs.SeverityNumber.INFO,
+        text: "INFO"
+      };
+  }
 }

package/dist/cjs/telemetry/telemetryConfigurator.cjs

@@ -11,21 +11,25 @@ var _sdkLogs = require("@opentelemetry/sdk-logs");
 var _sdkMetrics = require("@opentelemetry/sdk-metrics");
 var _hostMetrics = require("@opentelemetry/host-metrics");
 var _bootConfig = require("../config/bootConfig.cjs");
+var _pluginService = require("../tlm-plugin/pluginService.cjs");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 const configureTelemetry = oasTlmConfig => {
+  configurePlugins(oasTlmConfig);
   configureTraces(oasTlmConfig);
   configureMetrics(oasTlmConfig);
   configureLogs(oasTlmConfig);
   _logger.default.info("✅ Telemetry configured successfully. All exporters are ready");
 };
 exports.configureTelemetry = configureTelemetry;
+function configurePlugins(oasTlmConfig) {
+  _pluginService.pluginService.enabled = oasTlmConfig.plugins.enabled;
+}
 function configureTraces(oasTlmConfig) {
   // TRACES CONFIGURATION
   // [OT]Provider -> [OT]SpanProcessor(multiSpan) -> n Processors(eg mainProcessor, extra) -> 1 SpanExporter
   _telemetryRegistry.inMemoryDbSpanExporter.baseUrl = oasTlmConfig.general.baseUrl; // TODO this will be done with filters
   _telemetryRegistry.inMemoryDbSpanExporter.retentionTimeInSeconds = oasTlmConfig.traces.memoryExporter.retentionTimeSeconds;
   _telemetryRegistry.inMemoryDbSpanExporter.setEnabledValue(oasTlmConfig.traces.memoryExporter.enabled);
-  _telemetryRegistry.pluginSpanExporter.setEnabledValue(oasTlmConfig.plugins.enabled);
   const mainExporter = _telemetryRegistry.multiSpanExporter;
   let mainProcessor = new _sdkTraceNode.BatchSpanProcessor(mainExporter);
   if (_bootConfig.bootEnvVariables.OASTLM_BOOT_ENV !== 'production') {
@@ -33,7 +37,6 @@ function configureTraces(oasTlmConfig) {
     mainProcessor = new _sdkTraceNode.SimpleSpanProcessor(mainExporter);
   }
   mainExporter.addExporters(_telemetryRegistry.inMemoryDbSpanExporter); // Main exporter have at least the in-memory exporter used by the traces controller
-  mainExporter.addExporters(_telemetryRegistry.pluginSpanExporter);
   mainExporter.addExporters(oasTlmConfig.traces.extraExporters);
   _telemetryRegistry.dynamicMultiSpanProcessor.addProcessors(mainProcessor);
   _telemetryRegistry.dynamicMultiSpanProcessor.addProcessors(oasTlmConfig.traces.extraProcessors);
@@ -51,7 +54,6 @@ function configureLogs(oasTlmConfig) {
   }
   mainExporter.addExporters(_telemetryRegistry.inMemoryDbLogExporter); // Main exporter have at least the in-memory exporter used by the logs controller
   mainExporter.addExporters(oasTlmConfig.logs.extraExporters);
-  mainExporter.addExporters(_telemetryRegistry.pluginLogExporter); // Allow logs to be sent to plugins too
   _telemetryRegistry.dynamicMultiLogProcessor.addProcessors(mainProcessor);
   _telemetryRegistry.dynamicMultiLogProcessor.addProcessors(oasTlmConfig.logs.extraProcessors);
 }
@@ -65,14 +67,9 @@ function configureMetrics(oasTlmConfig) {
     exportIntervalMillis: oasTlmConfig.metrics.mainMetricReaderOptions.exportIntervalMillis,
     metricProducers: oasTlmConfig.metrics.mainMetricReaderOptions.metricProducers
   });
-  const pluginReader = new _sdkMetrics.PeriodicExportingMetricReader({
-    exporter: _telemetryRegistry.pluginMetricExporter,
-    exportIntervalMillis: oasTlmConfig.metrics.mainMetricReaderOptions.exportIntervalMillis,
-    metricProducers: oasTlmConfig.metrics.mainMetricReaderOptions.metricProducers
-  });
   const meterProvider = new _sdkMetrics.MeterProvider({
     resource: _telemetryRegistry.oasTelemetryResource,
-    readers: [mainReader, pluginReader, ...oasTlmConfig.metrics.extraReaders],
+    readers: [mainReader, ...oasTlmConfig.metrics.extraReaders],
     views: oasTlmConfig.metrics.extraViews || []
   });
   // TODO maybe hostMetrics are too much, consider using only a subset of them.

package/dist/cjs/telemetry/telemetryRegistry.cjs

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.pluginSpanExporter = exports.pluginMetricExporter = exports.pluginLogExporter = exports.oasTelemetryResource = exports.multiSpanExporter = exports.multiLogExporter = exports.inMemoryDbSpanExporter = exports.inMemoryDbMetricExporter = exports.inMemoryDbLogExporter = exports.dynamicMultiSpanProcessor = exports.dynamicMultiLogProcessor = void 0;
+exports.originalConsoleMethods = exports.oasTelemetryResource = exports.multiSpanExporter = exports.multiLogExporter = exports.inMemoryDbSpanExporter = exports.inMemoryDbMetricExporter = exports.inMemoryDbLogExporter = exports.dynamicMultiSpanProcessor = exports.dynamicMultiLogProcessor = void 0;
 var _InMemoryDbSpanExporter = require("./custom-implementations/exporters/InMemoryDbSpanExporter.cjs");
 var _wrappers = require("./custom-implementations/wrappers.cjs");
 var _InMemoryDbLogExporter = require("./custom-implementations/exporters/InMemoryDbLogExporter.cjs");
@@ -12,12 +12,10 @@ var _dynamicMultiSpanProcessor = require("./custom-implementations/processors/dy
 var _dynamicMultiLogProcessor = require("./custom-implementations/processors/dynamicMultiLogProcessor.cjs");
 var _semanticConventions = require("@opentelemetry/semantic-conventions");
 var _resources = require("@opentelemetry/resources");
-var _PluginSpanExporter = require("./custom-implementations/exporters/PluginSpanExporter.cjs");
-var _PluginLogExporter = require("./custom-implementations/exporters/PluginLogExporter.cjs");
-var _PluginMetricExporter = require("./custom-implementations/exporters/PluginMetricExporter.cjs");
+var _bootConfig = require("../config/bootConfig.cjs");
 // GLOBAL REGISTRY of telemetry components, used by SDKs and controllers.
 const oasTelemetryResource = exports.oasTelemetryResource = (0, _resources.resourceFromAttributes)({
-  [_semanticConventions.ATTR_SERVICE_NAME]: 'oas-telemetry-service'
+  [_semanticConventions.ATTR_SERVICE_NAME]: _bootConfig.bootEnvVariables.OASTLM_BOOT_SERVICE_NAME
 });
 // TRACES -------------------------------------------------------------------------------------
 // This is the main exporter for oas-telemetry spans. (Used by the traces controller)
@@ -26,15 +24,20 @@ const inMemoryDbSpanExporter = exports.inMemoryDbSpanExporter = new _InMemoryDbS
 const multiSpanExporter = exports.multiSpanExporter = new _wrappers.EnablerMultiSpanExporter();
 // This allows the addition of more processors at runtime
 const dynamicMultiSpanProcessor = exports.dynamicMultiSpanProcessor = new _dynamicMultiSpanProcessor.DynamicMultiSpanProcessor();
-const pluginSpanExporter = exports.pluginSpanExporter = new _PluginSpanExporter.PluginSpanExporter(); // This exporter sends spans to the plugin module.
 // LOGS ----------------------------------------------------------------------------------------
 const inMemoryDbLogExporter = exports.inMemoryDbLogExporter = new _InMemoryDbLogExporter.InMemoryDbLogExporter();
 const multiLogExporter = exports.multiLogExporter = new _wrappers.EnablerMultiLogExporter();
 const dynamicMultiLogProcessor = exports.dynamicMultiLogProcessor = new _dynamicMultiLogProcessor.DynamicMultiLogRecordProcessor();
-const pluginLogExporter = exports.pluginLogExporter = new _PluginLogExporter.PluginLogExporter(); // This exporter sends logs to the plugin module.
+// Override console methods to emit logs via OpenTelemetry, like an instrumentation
+const originalConsoleMethods = exports.originalConsoleMethods = {
+  log: console.log,
+  warn: console.warn,
+  error: console.error,
+  info: console.info,
+  debug: console.debug
+};
 // METRICS -------------------------------------------------------------------------------------
 // Metrics follow a different pattern in OpenTelemetry
 const inMemoryDbMetricExporter = exports.inMemoryDbMetricExporter = new _InMemoryDbMetricExporter.InMemoryDbMetricExporter();
-const pluginMetricExporter = exports.pluginMetricExporter = new _PluginMetricExporter.PluginMetricExporter(); // This exporter sends metrics to the plugin module.
 // Readers and their exporters cannot be grouped together in a MultiReader or similar construct
 // due to differences in aggregation temporality and aggregation selection.

package/dist/cjs/tlm-ai/agent.cjs

@@ -3,96 +3,66 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.getAgent = getAgent;
-var _openai = _interopRequireDefault(require("openai"));
+exports.agent = agent;
 var _tools = require("./tools.cjs");
 var _logger = _interopRequireDefault(require("../utils/logger.cjs"));
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-function getAgent(oasTlmConfig) {
-  let openai;
-  try {
-    if (!oasTlmConfig.ai.openAIKey) {
-      openai = null;
-    } else {
-      openai = new _openai.default({
-        apiKey: oasTlmConfig.ai.openAIKey ?? undefined,
-        dangerouslyAllowBrowser: true
-      });
-    }
-  } catch {
-    openai = null;
-  }
-  const messages = [{
-    role: "assistant",
-    content: "You are a helpful telemetry assistant. Only use the functions you have been provided with. If the question is not related to the functions, respond with 'I cannot help with that.'. If you need to call to other agents, do so using the tools provided."
-  }];
-  // Add extra context prompts if provided
-  if (oasTlmConfig.ai.extraContextPrompts) {
-    for (const prompt of oasTlmConfig.ai.extraContextPrompts) {
-      messages.push({
-        role: "system",
-        content: prompt
-      });
-    }
-  }
-  async function agent(userInput) {
-    if (!openai) {
-      _logger.default.error("OpenAI client is not initialized. Please check your OpenAI API key.");
-      return {
-        content: "OpenAI client is not initialized. Please check your OpenAI API key."
-      };
-    }
-    messages.push({
-      role: "user",
-      content: userInput
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+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); }
+async function agent(openai, messages, model = "gpt-3.5-turbo", extraPrompts = []) {
+  for (let i = 0; i < 5; i++) {
+    const modelResponse = await openai.chat.completions.create({
+      model,
+      messages,
+      tools: _tools.tools
     });
-    for (let i = 0; i < 5; i++) {
-      const response = await openai?.chat?.completions?.create?.({
-        model: oasTlmConfig.ai.openAIModel,
-        messages: messages,
-        tools: _tools.tools
-      });
-      const {
-        finish_reason,
-        message
-      } = response.choices[0];
-      if (finish_reason === "tool_calls" && message.tool_calls) {
-        _logger.default.debug("Tool calls detected:", message.tool_calls);
-        const results = [];
-        for (const toolCall of message.tool_calls) {
-          const functionName = toolCall.function.name;
-          const functionToCall = _tools.availableTools[functionName];
-          const functionArgs = JSON.parse(toolCall.function.arguments);
-          const functionArgsArr = Object.values(functionArgs);
-          // @ts-expect-error yes
-          // eslint-disable-next-line prefer-spread
-          const functionResponse = await functionToCall.apply(null, functionArgsArr);
-          results.push({
-            name: functionName,
-            response: functionResponse
-          });
-        }
-        const resultMessage = results.map(({
-          name,
-          response
-        }) => `Result from "${name}":\n${JSON.stringify(response, null, 2)}`).join("\n\n");
-        messages.push({
-          role: "function",
-          name: "multiple_tool_calls",
-          content: resultMessage
+    const {
+      finish_reason,
+      message
+    } = modelResponse.choices[0];
+    if (finish_reason === "tool_calls" && message.tool_calls) {
+      _logger.default.debug("Tool calls detected:", message.tool_calls);
+      const results = [];
+      for (const toolCall of message.tool_calls) {
+        const functionName = toolCall.function.name;
+        const functionToCall = _tools.availableTools[functionName];
+        const functionArgs = JSON.parse(toolCall.function.arguments);
+        const functionArgsArr = Object.values(functionArgs);
+        // @ts-expect-error yes
+        // eslint-disable-next-line prefer-spread
+        const functionResponse = await functionToCall.apply(null, functionArgsArr);
+        results.push({
+          name: functionName,
+          response: functionResponse
         });
-      } else if (finish_reason === "stop") {
-        messages.push(message);
-        return message;
       }
+      const resultMessage = results.map(({
+        name,
+        response
+      }, idx) => {
+        const toolCall = message.tool_calls?.[idx];
+        const params = toolCall ? JSON.parse(toolCall.function.arguments) : {};
+        return `Tool "${name}" called with parameters:\n${JSON.stringify(params, null, 2)}\nResult:\n${JSON.stringify(response, null, 2)}`;
+      }).join("\n\n");
+      messages.push({
+        role: "function",
+        name: "multiple_tool_calls",
+        content: resultMessage,
+        timestamp: new Date().toISOString()
+      });
+    } else if (finish_reason === "stop") {
+      messages.push(_objectSpread(_objectSpread({}, message), {}, {
+        timestamp: new Date().toISOString()
+      }));
+      return;
     }
-    return {
-      content: "Se alcanzó el número máximo de iteraciones sin una respuesta adecuada. Intenta con una consulta más específica."
-    };
   }
-  return async function getAgentResponse(question) {
-    const response = await agent(question);
-    _logger.default.debug("Response from agent:", response);
-    return response.content;
-  };
+  messages.push({
+    role: "assistant",
+    content: "Maximum iterations reached without a suitable response. Try a more specific query.",
+    timestamp: new Date().toISOString()
+  });
 }