@oas-tools/oas-telemetry 0.7.1 → 0.8.0-alpha.1

package/dist/cjs/telemetry/persistence/DiskWriter.cjs

@@ -0,0 +1,66 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiskWriter = void 0;
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const DiskUtils_js_1 = require("./DiskUtils.cjs");
+class DiskWriter {
+    directoryPath;
+    segmentPrefix;
+    maxSegmentBytes;
+    initialized = false;
+    currentSegmentIndex = 0;
+    currentSegmentPath = '';
+    currentSegmentSize = 0;
+    writeQueue = Promise.resolve();
+    constructor(options) {
+        this.directoryPath = path_1.default.resolve(options.directoryPath);
+        this.segmentPrefix = options.segmentPrefix || DiskUtils_js_1.DEFAULT_SEGMENT_PREFIX;
+        this.maxSegmentBytes = options.maxSegmentBytes || DiskUtils_js_1.DEFAULT_MAX_SEGMENT_BYTES;
+    }
+    async appendRecords(records) {
+        if (!records.length)
+            return;
+        const frame = (0, DiskUtils_js_1.encodeRecordBatchFrame)(records);
+        this.writeQueue = this.writeQueue.then(() => this.appendFrame(frame));
+        return this.writeQueue;
+    }
+    async flush() {
+        await this.writeQueue;
+    }
+    async ensureInitialized() {
+        if (this.initialized)
+            return;
+        await promises_1.default.mkdir(this.directoryPath, { recursive: true });
+        const segments = await (0, DiskUtils_js_1.listSegments)(this.directoryPath, this.segmentPrefix);
+        if (segments.length === 0) {
+            this.currentSegmentIndex = 0;
+            this.currentSegmentPath = path_1.default.join(this.directoryPath, (0, DiskUtils_js_1.getSegmentName)(this.currentSegmentIndex, this.segmentPrefix));
+            this.currentSegmentSize = 0;
+        }
+        else {
+            const lastSegment = segments[segments.length - 1];
+            this.currentSegmentIndex = lastSegment.index;
+            this.currentSegmentPath = lastSegment.filePath;
+            this.currentSegmentSize = (await promises_1.default.stat(lastSegment.filePath)).size;
+        }
+        this.initialized = true;
+    }
+    async rotateSegment() {
+        this.currentSegmentIndex += 1;
+        this.currentSegmentPath = path_1.default.join(this.directoryPath, (0, DiskUtils_js_1.getSegmentName)(this.currentSegmentIndex, this.segmentPrefix));
+        this.currentSegmentSize = 0;
+    }
+    async appendFrame(frame) {
+        await this.ensureInitialized();
+        if (this.currentSegmentSize > 0 && this.currentSegmentSize + frame.length > this.maxSegmentBytes) {
+            await this.rotateSegment();
+        }
+        await promises_1.default.appendFile(this.currentSegmentPath, frame);
+        this.currentSegmentSize += frame.length;
+    }
+}
+exports.DiskWriter = DiskWriter;

package/dist/cjs/telemetry/telemetryConfigurator.cjs

@@ -1,81 +1,148 @@
 "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");
-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");
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
 };
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.configureTelemetry = configureTelemetry;
+const sdk_logs_1 = require("@opentelemetry/sdk-logs");
+const sdk_metrics_1 = require("@opentelemetry/sdk-metrics");
+const sdk_trace_node_1 = require("@opentelemetry/sdk-trace-node");
+const logger_js_1 = __importDefault(require("../utils/logger.cjs"));
+const telemetryRegistry_js_1 = require("./telemetryRegistry.cjs");
+const sdk_node_1 = require("@opentelemetry/sdk-node");
+const bootConfig_js_1 = require("../config/bootConfig.cjs");
+const pluginService_js_1 = require("../tlm-plugin/pluginService.cjs");
+const DiskTraceExporter_js_1 = require("./custom-implementations/exporters/DiskTraceExporter.cjs");
+const DiskLogExporter_js_1 = require("./custom-implementations/exporters/DiskLogExporter.cjs");
+const DiskMetricExporter_js_1 = require("./custom-implementations/exporters/DiskMetricExporter.cjs");
+const MultiMetricExporter_js_1 = require("./custom-implementations/exporters/MultiMetricExporter.cjs");
+const DiskImporter_js_1 = require("./persistence/DiskImporter.cjs");
+const traceService_js_1 = require("../tlm-trace/traceService.cjs");
+const logService_js_1 = require("../tlm-log/logService.cjs");
+const metricsService_js_1 = require("../tlm-metric/metricsService.cjs");
+function configureTelemetry(oasTlmConfig) {
+    logger_js_1.default.info("🚀 Configuring Telemetry...");
+    configureStorage(oasTlmConfig);
+    if (oasTlmConfig.instrumentations) {
+        telemetryRegistry_js_1.instrumentations.push(...oasTlmConfig.instrumentations);
+    }
+    configurePlugins(oasTlmConfig);
+    const mainTraceProcessor = configureTraces(oasTlmConfig);
+    const mainMetricReader = configureMetrics(oasTlmConfig);
+    const mainLogProcessor = configureLogs(oasTlmConfig);
+    const sdk = new sdk_node_1.NodeSDK({
+        instrumentations: telemetryRegistry_js_1.instrumentations,
+        resource: telemetryRegistry_js_1.oasTelemetryResource,
+        traceExporter: telemetryRegistry_js_1.inMemoryDbSpanExporter,
+        spanProcessors: [mainTraceProcessor, ...oasTlmConfig.traces.extraProcessors || []],
+        metricReaders: [mainMetricReader, ...(oasTlmConfig.metrics.extraReaders || [])],
+        logRecordProcessors: [mainLogProcessor, ...oasTlmConfig.logs.extraProcessors || []],
+    });
+    sdk.start();
+    logger_js_1.default.info("✅ Node SDK started with telemetry configuration");
+    if (oasTlmConfig.storage.path && oasTlmConfig.storage.loadFromStart) {
+        scheduleStartupImports(oasTlmConfig.storage.path);
+    }
+    else if (oasTlmConfig.storage.path && !oasTlmConfig.storage.loadFromStart) {
+        logger_js_1.default.info(`[DiskImporter] Startup import skipped by storage.loadFromStart=false. Path: ${oasTlmConfig.storage.path}`);
+    }
+    return true;
+}
+function configureStorage(oasTlmConfig) {
+    const path = oasTlmConfig.storage.path;
+    oasTlmConfig.storage.path = typeof path === 'string' && path.trim().length > 0
+        ? path.trim()
+        : null;
+}
 function configurePlugins(oasTlmConfig) {
-  _pluginService.pluginService.enabled = oasTlmConfig.plugins.enabled;
+    pluginService_js_1.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);
-  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(oasTlmConfig.traces.extraExporters);
-  _telemetryRegistry.dynamicMultiSpanProcessor.addProcessors(mainProcessor);
-  _telemetryRegistry.dynamicMultiSpanProcessor.addProcessors(oasTlmConfig.traces.extraProcessors);
+    // TRACES CONFIGURATION
+    // [OT]Provider -> [OT]SpanProcessor(multiSpan) -> n Processors(eg mainProcessor, extra) -> 1 SpanExporter
+    telemetryRegistry_js_1.inMemoryDbSpanExporter.retentionTimeInSeconds = oasTlmConfig.traces.memoryExporter.retentionTimeSeconds;
+    telemetryRegistry_js_1.inMemoryDbSpanExporter.setEnabledValue(oasTlmConfig.traces.memoryExporter.enabled);
+    const mainExporter = telemetryRegistry_js_1.multiSpanExporter;
+    mainExporter.clearExporters();
+    let mainProcessor = new sdk_trace_node_1.BatchSpanProcessor(mainExporter);
+    if (bootConfig_js_1.bootEnvVariables.OASTLM_BOOT_ENV !== 'production') {
+        logger_js_1.default.info('Not in production, using SimpleSpanProcessor for traces');
+        mainProcessor = new sdk_trace_node_1.SimpleSpanProcessor(mainExporter);
+    }
+    mainExporter.addExporters(telemetryRegistry_js_1.inMemoryDbSpanExporter); // Main exporter have at least the in-memory exporter used by the traces controller
+    if (oasTlmConfig.storage.path) {
+        mainExporter.addExporters(new DiskTraceExporter_js_1.DiskTraceExporter({ directoryPath: oasTlmConfig.storage.path }));
+        logger_js_1.default.info(`[TraceDiskExporter] Enabled at: ${oasTlmConfig.storage.path}`);
+    }
+    mainExporter.addExporters(oasTlmConfig.traces.extraExporters);
+    return mainProcessor;
+}
+function configureMetrics(oasTlmConfig) {
+    // METRICS CONFIGURATION
+    telemetryRegistry_js_1.inMemoryDbMetricExporter.setEnabledValue(oasTlmConfig.metrics.memoryExporter.enabled);
+    telemetryRegistry_js_1.inMemoryDbMetricExporter.retentionTimeInSeconds = oasTlmConfig.metrics.memoryExporter.retentionTimeSeconds;
+    const metricExporters = [telemetryRegistry_js_1.inMemoryDbMetricExporter];
+    if (oasTlmConfig.storage.path) {
+        metricExporters.push(new DiskMetricExporter_js_1.DiskMetricExporter({ directoryPath: oasTlmConfig.storage.path }));
+        logger_js_1.default.info(`[MetricDiskExporter] Enabled at: ${oasTlmConfig.storage.path}`);
+    }
+    const mainReader = new sdk_metrics_1.PeriodicExportingMetricReader({
+        exporter: new MultiMetricExporter_js_1.MultiMetricExporter(metricExporters),
+        exportIntervalMillis: oasTlmConfig.metrics.mainMetricReaderOptions.exportIntervalMillis,
+        metricProducers: oasTlmConfig.metrics.mainMetricReaderOptions.metricProducers
+    });
+    return mainReader;
 }
 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);
-  _telemetryRegistry.dynamicMultiLogProcessor.addProcessors(mainProcessor);
-  _telemetryRegistry.dynamicMultiLogProcessor.addProcessors(oasTlmConfig.logs.extraProcessors);
+    // LOGS CONFIGURATION
+    // [OT]LoggerProvider -> [OT]LogRecordProcessor(multiLogProcessor) -> n Processors(eg mainProcessor, extra) -> 1 LogExporter
+    telemetryRegistry_js_1.inMemoryDbLogExporter.setEnabledValue(oasTlmConfig.logs.memoryExporter.enabled);
+    telemetryRegistry_js_1.inMemoryDbLogExporter.retentionTimeInSeconds = oasTlmConfig.logs.memoryExporter.retentionTimeSeconds;
+    const mainExporter = telemetryRegistry_js_1.multiLogExporter;
+    mainExporter.clearExporters();
+    let mainProcessor = new sdk_logs_1.BatchLogRecordProcessor(mainExporter);
+    if (bootConfig_js_1.bootEnvVariables.OASTLM_BOOT_ENV !== 'production') {
+        logger_js_1.default.info('Not in production, using SimpleLogRecordProcessor for logs');
+        mainProcessor = new sdk_logs_1.SimpleLogRecordProcessor(mainExporter);
+    }
+    mainExporter.addExporters(telemetryRegistry_js_1.inMemoryDbLogExporter); // Main exporter have at least the in-memory exporter used by the logs controller
+    if (oasTlmConfig.storage.path) {
+        mainExporter.addExporters(new DiskLogExporter_js_1.DiskLogExporter({ directoryPath: oasTlmConfig.storage.path }));
+        logger_js_1.default.info(`[LogDiskExporter] Enabled at: ${oasTlmConfig.storage.path}`);
+    }
+    mainExporter.addExporters(oasTlmConfig.logs.extraExporters);
+    return mainProcessor;
+}
+function scheduleStartupImports(storagePath) {
+    setTimeout(async () => {
+        try {
+            await runTimedImport('TraceDiskImport', storagePath, new DiskImporter_js_1.DiskImporter({ directoryPath: storagePath }), async (spans) => {
+                await (0, traceService_js_1.importTracesToMemory)(spans);
+            });
+            await runTimedImport('LogDiskImport', storagePath, new DiskImporter_js_1.DiskImporter({ directoryPath: storagePath, segmentPrefix: 'logs' }), async (logs) => {
+                await (0, logService_js_1.importLogsToMemory)(logs);
+            });
+            await runTimedImport('MetricDiskImport', storagePath, new DiskImporter_js_1.DiskImporter({ directoryPath: storagePath, segmentPrefix: 'metrics' }), async (scopeMetrics) => {
+                (0, metricsService_js_1.importMetricsToMemory)(scopeMetrics, { format: 'otel' });
+            });
+        }
+        catch (error) {
+            logger_js_1.default.error(`[DiskImporter] Startup import sequence failed: ${error?.message || error}`);
+        }
+    }, 0);
+}
+async function runTimedImport(label, storagePath, importer, onBatch) {
+    const startedAt = Date.now();
+    logger_js_1.default.info(`[${label}] Startup import started. Path: ${storagePath}`);
+    try {
+        const result = await importer.import(onBatch);
+        logger_js_1.default.info(`[${label}] Startup import completed. Files: ${result.segmentFilesRead}, imported records: ${result.importedRecords}, failed frames: ${result.failedFrames}`);
+    }
+    catch (error) {
+        logger_js_1.default.error(`[${label}] Startup import failed: ${error?.message || error}`);
+    }
+    finally {
+        const elapsedMs = Date.now() - startedAt;
+        logger_js_1.default.info(`[${label}] Startup import finished in ${elapsedMs}ms`);
+    }
 }
-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 meterProvider = new _sdkMetrics.MeterProvider({
-    resource: _telemetryRegistry.oasTelemetryResource,
-    readers: [mainReader, ...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

@@ -1,43 +1,57 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-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");
-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 _bootConfig = require("../config/bootConfig.cjs");
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.instrumentations = exports.inMemoryDbMetricExporter = exports.originalConsoleMethods = exports.dynamicMultiLogProcessor = exports.multiLogExporter = exports.inMemoryDbLogExporter = exports.dynamicMultiSpanProcessor = exports.multiSpanExporter = exports.inMemoryDbSpanExporter = exports.oasTelemetryResource = void 0;
+exports.isBootInitialized = isBootInitialized;
+exports.setBootInitialized = setBootInitialized;
+exports.isTelemetryConfigured = isTelemetryConfigured;
+exports.setTelemetryConfigured = setTelemetryConfigured;
+exports.setTelemetryRouter = setTelemetryRouter;
+exports.getTelemetryRouter = getTelemetryRouter;
+const InMemoryDbSpanExporter_js_1 = require("./custom-implementations/exporters/InMemoryDbSpanExporter.cjs");
+const wrappers_js_1 = require("./custom-implementations/wrappers.cjs");
+const InMemoryDbLogExporter_js_1 = require("./custom-implementations/exporters/InMemoryDbLogExporter.cjs");
+const InMemoryDbMetricExporter_js_1 = require("./custom-implementations/exporters/InMemoryDbMetricExporter.cjs");
+const dynamicMultiSpanProcessor_js_1 = require("./custom-implementations/processors/dynamicMultiSpanProcessor.cjs");
+const dynamicMultiLogProcessor_js_1 = require("./custom-implementations/processors/dynamicMultiLogProcessor.cjs");
+const semantic_conventions_1 = require("@opentelemetry/semantic-conventions");
+const resources_1 = require("@opentelemetry/resources");
+const bootConfig_js_1 = 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]: _bootConfig.bootEnvVariables.OASTLM_BOOT_SERVICE_NAME
+let _bootInitialized = false;
+let _telemetryConfigured = false;
+let _router = undefined;
+function isBootInitialized() { return _bootInitialized; }
+function setBootInitialized(v) { _bootInitialized = v; }
+function isTelemetryConfigured() { return _telemetryConfigured; }
+function setTelemetryConfigured(v) { _telemetryConfigured = v; }
+function setTelemetryRouter(router) { _router = router; }
+function getTelemetryRouter() { return _router; }
+exports.oasTelemetryResource = (0, resources_1.resourceFromAttributes)({
+    [semantic_conventions_1.ATTR_SERVICE_NAME]: bootConfig_js_1.bootEnvVariables.OASTLM_BOOT_SERVICE_NAME
 });
 // TRACES -------------------------------------------------------------------------------------
 // This is the main exporter for oas-telemetry spans. (Used by the traces controller)
-const inMemoryDbSpanExporter = exports.inMemoryDbSpanExporter = new _InMemoryDbSpanExporter.InMemoryDbSpanExporter();
+exports.inMemoryDbSpanExporter = new InMemoryDbSpanExporter_js_1.InMemoryDbSpanExporter();
 // This allows to add more exporter in the future without changing the code
-const multiSpanExporter = exports.multiSpanExporter = new _wrappers.EnablerMultiSpanExporter();
+exports.multiSpanExporter = new wrappers_js_1.EnablerMultiSpanExporter();
 // This allows the addition of more processors at runtime
-const dynamicMultiSpanProcessor = exports.dynamicMultiSpanProcessor = new _dynamicMultiSpanProcessor.DynamicMultiSpanProcessor();
+exports.dynamicMultiSpanProcessor = new dynamicMultiSpanProcessor_js_1.DynamicMultiSpanProcessor();
 // LOGS ----------------------------------------------------------------------------------------
-const inMemoryDbLogExporter = exports.inMemoryDbLogExporter = new _InMemoryDbLogExporter.InMemoryDbLogExporter();
-const multiLogExporter = exports.multiLogExporter = new _wrappers.EnablerMultiLogExporter();
-const dynamicMultiLogProcessor = exports.dynamicMultiLogProcessor = new _dynamicMultiLogProcessor.DynamicMultiLogRecordProcessor();
-// 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
+exports.inMemoryDbLogExporter = new InMemoryDbLogExporter_js_1.InMemoryDbLogExporter();
+exports.multiLogExporter = new wrappers_js_1.EnablerMultiLogExporter();
+exports.dynamicMultiLogProcessor = new dynamicMultiLogProcessor_js_1.DynamicMultiLogRecordProcessor();
+// For custom log instrumentation, and lib logging
+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();
+exports.inMemoryDbMetricExporter = new InMemoryDbMetricExporter_js_1.InMemoryDbMetricExporter();
 // Readers and their exporters cannot be grouped together in a MultiReader or similar construct
-// due to differences in aggregation temporality and aggregation selection.
+// due to differences in aggregation temporality and aggregation selection.
+// INSTRUMENTATIONS -----------------------------------------------------------------------
+exports.instrumentations = [];

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

@@ -1,68 +1,53 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
 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 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
-    });
-    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
+const tools_js_1 = require("./tools.cjs");
+const logger_js_1 = __importDefault(require("../utils/logger.cjs"));
+async function agent(openai, messages, model = "gpt-3.5-turbo") {
+    for (let i = 0; i < 5; i++) {
+        const modelResponse = await openai.chat.completions.create({
+            model,
+            messages,
+            tools: tools_js_1.tools,
         });
-      }
-      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;
+        const { finish_reason, message } = modelResponse.choices[0];
+        if (finish_reason === "tool_calls" && message.tool_calls) {
+            logger_js_1.default.debug("Tool calls detected:", message.tool_calls);
+            const results = [];
+            for (const toolCall of message.tool_calls) {
+                // Type guard for tool_calls
+                if (toolCall.type !== 'function' || !toolCall.function)
+                    continue;
+                const functionName = toolCall.function.name;
+                const functionToCall = tools_js_1.availableTools[functionName];
+                const functionArgs = JSON.parse(toolCall.function.arguments);
+                const functionArgsArr = Object.values(functionArgs);
+                // 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 }, idx) => {
+                const toolCall = message.tool_calls?.[idx];
+                const params = toolCall && toolCall.type === 'function' && toolCall.function ? 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({ ...message, timestamp: new Date().toISOString() });
+            return;
+        }
     }
-  }
-  messages.push({
-    role: "assistant",
-    content: "Maximum iterations reached without a suitable response. Try a more specific query.",
-    timestamp: new Date().toISOString()
-  });
-}
+    messages.push({ role: "assistant", content: "Maximum iterations reached without a suitable response. Try a more specific query.", timestamp: new Date().toISOString() });
+}