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

package/dist/cjs/telemetry/telemetryConfigurator.cjs

@@ -0,0 +1,84 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.configureTelemetry = void 0;
+var _sdkTraceNode = require("@opentelemetry/sdk-trace-node");
+var _telemetryRegistry = require("./telemetryRegistry.cjs");
+var _logger = _interopRequireDefault(require("../utils/logger.cjs"));
+var _sdkLogs = require("@opentelemetry/sdk-logs");
+var _sdkMetrics = require("@opentelemetry/sdk-metrics");
+var _hostMetrics = require("@opentelemetry/host-metrics");
+var _bootConfig = require("../config/bootConfig.cjs");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const configureTelemetry = oasTlmConfig => {
+  configureTraces(oasTlmConfig);
+  configureMetrics(oasTlmConfig);
+  configureLogs(oasTlmConfig);
+  _logger.default.info("✅ Telemetry configured successfully. All exporters are ready");
+};
+exports.configureTelemetry = configureTelemetry;
+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') {
+    _logger.default.info('Not in production, using SimpleSpanProcessor for traces');
+    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);
+}
+function configureLogs(oasTlmConfig) {
+  // LOGS CONFIGURATION
+  // [OT]LoggerProvider -> [OT]LogRecordProcessor(multiLogProcessor) -> n Processors(eg mainProcessor, extra) -> 1 LogExporter
+  _telemetryRegistry.inMemoryDbLogExporter.setEnabledValue(oasTlmConfig.logs.memoryExporter.enabled);
+  _telemetryRegistry.inMemoryDbLogExporter.retentionTimeInSeconds = oasTlmConfig.logs.memoryExporter.retentionTimeSeconds;
+  const mainExporter = _telemetryRegistry.multiLogExporter;
+  let mainProcessor = new _sdkLogs.BatchLogRecordProcessor(mainExporter);
+  if (_bootConfig.bootEnvVariables.OASTLM_BOOT_ENV !== 'production') {
+    _logger.default.info('Not in production, using SimpleLogRecordProcessor for logs');
+    mainProcessor = new _sdkLogs.SimpleLogRecordProcessor(mainExporter);
+  }
+  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);
+}
+function configureMetrics(oasTlmConfig) {
+  // METRICS CONFIGURATION
+  // [CUSTOM]MeterProvider -> n [OTel]MetricReader -> (0-1) MetricExporter (only if push-based reader)
+  _telemetryRegistry.inMemoryDbMetricExporter.setEnabledValue(oasTlmConfig.metrics.memoryExporter.enabled);
+  _telemetryRegistry.inMemoryDbMetricExporter.retentionTimeInSeconds = oasTlmConfig.metrics.memoryExporter.retentionTimeSeconds;
+  const mainReader = new _sdkMetrics.PeriodicExportingMetricReader({
+    exporter: _telemetryRegistry.inMemoryDbMetricExporter,
+    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],
+    views: oasTlmConfig.metrics.extraViews || []
+  });
+  // TODO maybe hostMetrics are too much, consider using only a subset of them.
+  const hostMetrics = new _hostMetrics.HostMetrics({
+    meterProvider: meterProvider
+  });
+  // AFTER adding all readers, start the instrumentations
+  hostMetrics.start();
+}

package/dist/cjs/telemetry/telemetryRegistry.cjs

@@ -0,0 +1,40 @@
+"use strict";
+
+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;
+var _InMemoryDbSpanExporter = require("./custom-implementations/exporters/InMemoryDbSpanExporter.cjs");
+var _wrappers = require("./custom-implementations/wrappers.cjs");
+var _InMemoryDbLogExporter = require("./custom-implementations/exporters/InMemoryDbLogExporter.cjs");
+var _InMemoryDbMetricExporter = require("./custom-implementations/exporters/InMemoryDbMetricExporter.cjs");
+var _dynamicMultiSpanProcessor = require("./custom-implementations/processors/dynamicMultiSpanProcessor.cjs");
+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");
+// GLOBAL REGISTRY of telemetry components, used by SDKs and controllers.
+const oasTelemetryResource = exports.oasTelemetryResource = (0, _resources.resourceFromAttributes)({
+  [_semanticConventions.ATTR_SERVICE_NAME]: 'oas-telemetry-service'
+});
+// TRACES -------------------------------------------------------------------------------------
+// This is the main exporter for oas-telemetry spans. (Used by the traces controller)
+const inMemoryDbSpanExporter = exports.inMemoryDbSpanExporter = new _InMemoryDbSpanExporter.InMemoryDbSpanExporter();
+// This allows to add more exporter in the future without changing the code
+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.
+// 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,77 +3,96 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.getAgentResponse = getAgentResponse;
+exports.getAgent = getAgent;
 var _openai = _interopRequireDefault(require("openai"));
-var _dotenv = _interopRequireDefault(require("dotenv"));
 var _tools = require("./tools.cjs");
 var _logger = _interopRequireDefault(require("../utils/logger.cjs"));
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-_dotenv.default.config();
-let openai;
-try {
-  openai = new _openai.default({
-    apiKey: process.env.OASTLM_AI_OPENAI_API_KEY,
-    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."
-}];
-async function agent(userInput) {
-  messages.push({
-    role: "user",
-    content: userInput
-  });
-  for (let i = 0; i < 5; i++) {
-    const response = await openai?.chat?.completions?.create?.({
-      model: process.env.OASTLM_AI_OPENAI_MODEL_NAME || "gpt-4o-mini",
-      messages: messages,
-      tools: _tools.tools
+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
     });
-    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
+    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
         });
+      } else if (finish_reason === "stop") {
+        messages.push(message);
+        return message;
       }
-      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
-      });
-    } else if (finish_reason === "stop") {
-      messages.push(message);
-      return message;
     }
+    return {
+      content: "Se alcanzó el número máximo de iteraciones sin una respuesta adecuada. Intenta con una consulta más específica."
+    };
   }
-  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;
   };
-}
-async function getAgentResponse(question) {
-  const response = await agent(question);
-  _logger.default.debug("Response from agent:", response);
-  return response.content;
 }

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

@@ -8,7 +8,7 @@ var _agent = require("./agent.cjs");
 var _knownMicroservices = require("./knownMicroservices.cjs");
 var _logger = _interopRequireDefault(require("../utils/logger.cjs"));
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-const answerQuestion = async (req, res) => {
+const answerQuestion = oasTlmConfig => async (req, res) => {
   try {
     const {
       question
@@ -16,7 +16,8 @@ const answerQuestion = async (req, res) => {
     if (!question) res.status(400).json({
       error: 'Missing question'
     });
-    const answer = await (0, _agent.getAgentResponse)(question);
+    const getAgentResponse = (0, _agent.getAgent)(oasTlmConfig);
+    const answer = await getAgentResponse(question);
     res.json({
       answer
     });
@@ -28,7 +29,7 @@ const answerQuestion = async (req, res) => {
   }
 };
 exports.answerQuestion = answerQuestion;
-const setKnownMicroservicesHandler = (req, res) => {
+const setKnownMicroservicesHandler = () => (req, res) => {
   try {
     const {
       microservices
@@ -53,7 +54,7 @@ const setKnownMicroservicesHandler = (req, res) => {
   }
 };
 exports.setKnownMicroservicesHandler = setKnownMicroservicesHandler;
-const getKnownMicroservicesHandler = (req, res) => {
+const getKnownMicroservicesHandler = () => (req, res) => {
   try {
     const microservices = (0, _knownMicroservices.getKnownMicroservices)();
     res.json({

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

@@ -3,11 +3,14 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = exports.aiRoutes = void 0;
+exports.getAIRoutes = void 0;
 var _express = require("express");
 var _aiController = require("./aiController.cjs");
-const aiRoutes = exports.aiRoutes = (0, _express.Router)();
-aiRoutes.post('/chat', _aiController.answerQuestion);
-aiRoutes.post('/microservices', _aiController.setKnownMicroservicesHandler); // New route for configuring microservices
-aiRoutes.get('/microservices', _aiController.getKnownMicroservicesHandler); // Route to retrieve the list of known microservices
-var _default = exports.default = aiRoutes;
+const getAIRoutes = oasTlmConfig => {
+  const router = (0, _express.Router)();
+  router.post('/chat', (0, _aiController.answerQuestion)(oasTlmConfig));
+  router.post('/microservices', (0, _aiController.setKnownMicroservicesHandler)());
+  router.get('/microservices', (0, _aiController.getKnownMicroservicesHandler)());
+  return router;
+};
+exports.getAIRoutes = getAIRoutes;

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

@@ -5,16 +5,16 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.tools = exports.availableTools = void 0;
 var _axios = _interopRequireDefault(require("axios"));
-var _config = require("../config.cjs");
 var _logger = _interopRequireDefault(require("../utils/logger.cjs"));
 var _knownMicroservices = require("./knownMicroservices.cjs");
+var _telemetryRegistry = require("../telemetry/telemetryRegistry.cjs");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 const getTraces = async searchInput => {
   _logger.default.debug("getTraces called with searchInput:", searchInput);
   try {
     const search = searchInput || {};
     const traces = await new Promise((resolve, reject) => {
-      _config.globalOasTlmConfig.dynamicSpanExporter.exporter.find(search, (err, docs) => {
+      _telemetryRegistry.inMemoryDbSpanExporter.find(search, (err, docs) => {
         if (err) reject(err);else resolve(docs);
       });
     });
@@ -47,7 +47,7 @@ const getLogs = async (startDate, endDate) => {
     }
     const logs = [];
     await new Promise((resolve, reject) => {
-      _config.globalOasTlmConfig.logExporter.find(nedbQuery, null, (err, docs) => {
+      _telemetryRegistry.inMemoryDbLogExporter.find(nedbQuery, null, (err, docs) => {
         if (err) {
           reject(err);
         } else {
@@ -71,7 +71,7 @@ const getMetrics = async searchInput => {
   try {
     const search = searchInput || {};
     const metrics = await new Promise((resolve, reject) => {
-      _config.globalOasTlmConfig.metricsExporter.find(search, (err, docs) => {
+      _telemetryRegistry.inMemoryDbMetricExporter.find(search, (err, docs) => {
         if (err) reject(err);else resolve(docs || []);
       });
     });
@@ -96,21 +96,28 @@ const getCurrentTimestampInEpoch = () => {
 };
 const startTelemetry = () => {
   _logger.default.debug("Starting telemetry...");
-  _config.globalOasTlmConfig.dynamicSpanExporter.exporter.start();
+  _telemetryRegistry.inMemoryDbSpanExporter.enable();
+  _telemetryRegistry.inMemoryDbLogExporter.enable();
+  _telemetryRegistry.inMemoryDbMetricExporter.enable();
 };
 const stopTelemetry = () => {
   _logger.default.debug("Stopping telemetry...");
-  _config.globalOasTlmConfig.dynamicSpanExporter.exporter.stop();
+  _telemetryRegistry.inMemoryDbSpanExporter.disable();
+  _telemetryRegistry.inMemoryDbLogExporter.disable();
+  _telemetryRegistry.inMemoryDbMetricExporter.disable();
 };
 const resetTelemetry = () => {
   _logger.default.debug("Resetting telemetry...");
-  _config.globalOasTlmConfig.dynamicSpanExporter.exporter.reset();
+  _telemetryRegistry.inMemoryDbSpanExporter.reset();
+  _telemetryRegistry.inMemoryDbLogExporter.reset();
+  _telemetryRegistry.inMemoryDbMetricExporter.reset();
 };
 const getTelemetryStatus = () => {
   _logger.default.debug("Getting telemetry status...");
-  const isRunning = _config.globalOasTlmConfig.dynamicSpanExporter.exporter.isRunning() || false;
   return {
-    active: isRunning
+    spansEnabled: _telemetryRegistry.inMemoryDbSpanExporter.isEnabled(),
+    logsEnabled: _telemetryRegistry.inMemoryDbLogExporter.isEnabled(),
+    metricsEnabled: _telemetryRegistry.inMemoryDbMetricExporter.isEnabled()
   };
 };
 const talkToExternalMicroserviceAgent = async (message, microserviceId) => {

package/dist/cjs/tlm-auth/authController.cjs

@@ -3,26 +3,25 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.logout = exports.login = exports.check = void 0;
-var _config = require("../config.cjs");
+exports.getLogout = exports.getLogin = exports.getCheck = void 0;
 var _jsonwebtoken = _interopRequireDefault(require("jsonwebtoken"));
 var _logger = _interopRequireDefault(require("../utils/logger.cjs"));
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-const login = (req, res) => {
+const getLogin = oasTlmConfig => (req, res) => {
   try {
     const {
       password
     } = req.body;
-    if (password === _config.globalOasTlmConfig.password) {
+    if (password === oasTlmConfig.auth.password) {
       const options = {
-        maxAge: _config.globalOasTlmConfig.apiKeyMaxAge,
+        maxAge: oasTlmConfig.auth.apiKeyMaxAge,
         httpOnly: true,
         secure: true,
         signed: false
       };
       const apiKey = _jsonwebtoken.default.sign({
-        password: _config.globalOasTlmConfig.password
-      }, _config.globalOasTlmConfig.jwtSecret);
+        password: oasTlmConfig.auth.password
+      }, oasTlmConfig.auth.jwtSecret);
       res.cookie('apiKey', apiKey, options);
       res.status(200).json({
         valid: true,
@@ -42,13 +41,13 @@ const login = (req, res) => {
     });
   }
 };
-exports.login = login;
-const logout = (req, res) => {
+exports.getLogin = getLogin;
+const getLogout = oasTlmConfig => (req, res) => {
   res.clearCookie('apiKey');
-  res.redirect(_config.globalOasTlmConfig.baseURL + '/login');
+  res.redirect(oasTlmConfig.general.baseUrl + oasTlmConfig.general.uiPath + '/login');
 };
-exports.logout = logout;
-const check = (req, res) => {
+exports.getLogout = getLogout;
+const getCheck = oasTlmConfig => (req, res) => {
   if (!req.cookies.apiKey) {
     res.status(200).json({
       valid: false,
@@ -56,8 +55,8 @@ const check = (req, res) => {
     });
     return;
   }
-  const decoded = _jsonwebtoken.default.verify(req.cookies.apiKey, _config.globalOasTlmConfig.jwtSecret);
-  if (decoded.password === _config.globalOasTlmConfig.password) {
+  const decoded = _jsonwebtoken.default.verify(req.cookies.apiKey, oasTlmConfig.auth.jwtSecret);
+  if (decoded.password === oasTlmConfig.auth.password) {
     res.status(200).json({
       valid: true,
       message: 'API Key is valid'
@@ -69,4 +68,4 @@ const check = (req, res) => {
     message: 'Invalid API Key'
   });
 };
-exports.check = check;
+exports.getCheck = getCheck;

package/dist/cjs/tlm-auth/authMiddleware.cjs

@@ -3,17 +3,18 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.authMiddleware = authMiddleware;
-var _config = require("../config.cjs");
+exports.getAuthMiddleware = getAuthMiddleware;
 var _jsonwebtoken = _interopRequireDefault(require("jsonwebtoken"));
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-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();
+function getAuthMiddleware(oasTlmConfig) {
+  return function authMiddleware(req, res, next) {
+    const apiKey = req.cookies.apiKey;
+    if (apiKey) {
+      const decoded = _jsonwebtoken.default.verify(apiKey, oasTlmConfig.auth.jwtSecret);
+      if (decoded.password === oasTlmConfig.auth.password) {
+        return next();
+      }
     }
-  }
-  res.status(401).redirect(_config.globalOasTlmConfig.baseURL + '/login');
+    res.status(401).redirect(oasTlmConfig.general.baseUrl + oasTlmConfig.general.uiPath + '/login');
+  };
 }

package/dist/cjs/tlm-auth/authRoutes.cjs

@@ -3,12 +3,14 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = void 0;
+exports.getAuthRoutes = void 0;
 var _express = require("express");
 var _authController = require("./authController.cjs");
-const router = (0, _express.Router)();
-router.post('/login', _authController.login);
-router.get('/logout', _authController.logout);
-router.get('/check', _authController.check);
-var _default = exports.default = router;
-module.exports = exports.default;
+const getAuthRoutes = oasTlmConfig => {
+  const router = (0, _express.Router)();
+  router.post('/login', (0, _authController.getLogin)(oasTlmConfig));
+  router.get('/logout', (0, _authController.getLogout)(oasTlmConfig));
+  router.get('/check', (0, _authController.getCheck)(oasTlmConfig));
+  return router;
+};
+exports.getAuthRoutes = getAuthRoutes;