@oas-tools/oas-telemetry 0.8.0-alpha.0 → 0.8.0-alpha.2

package/.env.example

@@ -10,7 +10,7 @@ OASTLM_BOOT_ENV=
 OASTLM_BOOT_MODULE_DISABLED=
 # Logging level for the boot process | Possible values: "DEBUG", "INFO", "WARNING", "ERROR", "NONE" | Default: "INFO"
 OASTLM_BOOT_LOG_LEVEL=
-# The name of your application or service | Default: "SERVICE-<random-uuid>"
+# The service name | Default: "UNKNOWN"
 OASTLM_BOOT_SERVICE_NAME=
 # Base URL path for telemetry endpoints (must be set at boot time, cannot be changed at runtime) | Default: "/oas-telemetry"
 OASTLM_BOOT_BASE_URL=
@@ -23,17 +23,6 @@ OASTLM_BOOT_AUTOINSTRUMENTATIONS_NODE_DISABLED=
 # Disable logs instrumentation auto-registration | Possible values: "true", "false" | Default: "false"
 OASTLM_BOOT_AUTOINSTRUMENTATIONS_LOGS_DISABLED=
 
-# BOOT-STORAGE CONFIGURATION ------------------------------------------------
-# Storage configuration for telemetry data (set at startup, cannot be changed at runtime).
-# If empty or not set: telemetry stored IN-MEMORY (default, lost on restart)
-# If set: telemetry persisted to DISK at specified path
-# Examples:
-#   OASTLM_BOOT_STORAGE_PATH=                    # empty = in-memory
-#   OASTLM_BOOT_STORAGE_PATH=data/telemetry      # disk storage
-#   OASTLM_BOOT_STORAGE_PATH=/var/lib/telemetry  # absolute path
-# Default: empty (in-memory)
-OASTLM_BOOT_STORAGE_PATH=
-
 
 # CONFIGURATION --------------------------------------------------------
 # These variables are used to override the configuration when oasTelemetry(config) is called.
@@ -42,6 +31,12 @@ OASTLM_BOOT_STORAGE_PATH=
 # Specification file name | Default: null
 OASTLM_CONFIG_GENERAL_SPEC_FILE_NAME=
 
+# Storage path: empty string = in-memory, else = disk storage at specified path | Default: empty string (in-memory)
+OASTLM_CONFIG_STORAGE_PATH=
+# Optional override for startup disk import behavior
+# Priority: OASTLM_CONFIG_STORAGE_LOAD_FROM_START > userConfig.storage.loadFromStart > defaultConfig
+OASTLM_CONFIG_STORAGE_LOAD_FROM_START=
+
 
 # Enable authentication | Possible values: "true", "false" | Default: "false"
 OASTLM_CONFIG_AUTH_ENABLED=

package/dist/cjs/config/bootConfig.cjs

@@ -5,7 +5,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.bootEnvVariables = void 0;
 const dotenv_1 = __importDefault(require("dotenv"));
-const crypto_1 = require("crypto");
 if (process.env.NODE_ENV !== 'test') {
     dotenv_1.default.config();
 }
@@ -15,11 +14,9 @@ exports.bootEnvVariables = {
     OASTLM_BOOT_ENV: process.env.OASTLM_BOOT_ENV || process.env.NODE_ENV || 'production',
     OASTLM_BOOT_MODULE_DISABLED: process.env.OASTLM_BOOT_MODULE_DISABLED === 'true',
     OASTLM_BOOT_LOG_LEVEL: process.env.OASTLM_BOOT_LOG_LEVEL || 'INFO',
-    OASTLM_BOOT_SERVICE_NAME: process.env.OASTLM_BOOT_SERVICE_NAME || `SERVICE-${(0, crypto_1.randomUUID)().slice(0, 8).toUpperCase()}`,
+    OASTLM_BOOT_SERVICE_NAME: process.env.OASTLM_BOOT_SERVICE_NAME || 'UNKNOWN',
     OASTLM_BOOT_BASE_URL: process.env.OASTLM_BOOT_BASE_URL || '/oas-telemetry',
     OASTLM_BOOT_AUTOINSTRUMENTATIONS_NODE_DISABLED: process.env.OASTLM_BOOT_AUTOINSTRUMENTATIONS_NODE_DISABLED == 'true',
     OASTLM_BOOT_AUTOINSTRUMENTATIONS_LOGS_DISABLED: process.env.OASTLM_BOOT_AUTOINSTRUMENTATIONS_LOGS_DISABLED == 'true',
-    // Storage path: empty string = in-memory, else = disk storage at specified path
-    OASTLM_BOOT_STORAGE_PATH: process.env.OASTLM_BOOT_STORAGE_PATH || '',
 };
 // REMEMBER TO UPDATE THE .env.example FILE WITH ANY NEW BOOT VARIABLE ADDED HERE.

package/dist/cjs/config/config.cjs

@@ -14,6 +14,10 @@ const loadEnv = () => {
             specFileName: getParsedEnvVar("OASTLM_CONFIG_GENERAL_SPEC_FILE_NAME"),
             // spec Not settable via env
         },
+        storage: {
+            path: getParsedEnvVar("OASTLM_CONFIG_STORAGE_PATH"),
+            loadFromStart: getParsedEnvVar("OASTLM_CONFIG_STORAGE_LOAD_FROM_START", (v) => v === "true"),
+        },
         auth: {
             enabled: getParsedEnvVar("OASTLM_CONFIG_AUTH_ENABLED", (v) => v === "true"),
             password: getParsedEnvVar("OASTLM_CONFIG_AUTH_PASSWORD"),
@@ -64,6 +68,10 @@ exports.defaultConfig = {
         spec: null, // e.g. JSON.stringify(oasSpec) or null if not provided,
         uiPath: "/oas-telemetry-ui", // path to the UI, e.g. "/oas-telemetry-ui" WARN: This must match the UI package's App.tsx "oas-telemetry-ui" path
     },
+    storage: {
+        path: null, // Optional disk persistence directory.
+        loadFromStart: true, // If true, import persisted telemetry into memory at startup.
+    },
     auth: {
         enabled: false,
         password: "oas-telemetry-password",

package/dist/cjs/docs/openapi.yaml

@@ -331,12 +331,12 @@ paths:
       tags:
         - traces
       summary: Export collected traces
-      description: Export all collected traces in NDJSON format
+      description: Export all collected traces in line-delimited JSON format
       responses:
         '200':
           description: Traces exported successfully
           content:
-            application/x-ndjson:
+            application/json:
               schema:
                 type: string
 
@@ -345,11 +345,11 @@ paths:
       tags:
         - traces
       summary: Import traces
-      description: Import traces from NDJSON format
+      description: Import traces from line-delimited JSON format
       requestBody:
         required: true
         content:
-          application/x-ndjson:
+          application/json:
             schema:
               type: string
       responses:
@@ -591,12 +591,12 @@ paths:
       tags:
         - metrics
       summary: Export collected metrics
-      description: Export all collected metrics in NDJSON format
+      description: Export all collected metrics in line-delimited JSON format
       responses:
         '200':
           description: Metrics exported successfully
           content:
-            application/x-ndjson:
+            application/json:
               schema:
                 type: string
 
@@ -605,11 +605,11 @@ paths:
       tags:
         - metrics
       summary: Import metrics
-      description: Import metrics from NDJSON format
+      description: Import metrics from line-delimited JSON format
       requestBody:
         required: true
         content:
-          application/x-ndjson:
+          application/json:
             schema:
               type: string
       responses:
@@ -789,12 +789,12 @@ paths:
       tags:
         - logs
       summary: Export collected logs
-      description: Export all collected logs in NDJSON format
+      description: Export all collected logs in line-delimited JSON format
       responses:
         '200':
           description: Logs exported successfully
           content:
-            application/x-ndjson:
+            application/json:
               schema:
                 type: string
 
@@ -803,11 +803,11 @@ paths:
       tags:
         - logs
       summary: Import logs
-      description: Import logs from NDJSON format
+      description: Import logs from line-delimited JSON format
       requestBody:
         required: true
         content:
-          application/x-ndjson:
+          application/json:
             schema:
               type: string
       responses:

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

@@ -0,0 +1,121 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiskLogExporter = void 0;
+const core_1 = require("@opentelemetry/core");
+const circular_js_1 = require("../utils/circular.cjs");
+const wrappers_js_1 = require("../wrappers.cjs");
+const DiskWriter_js_1 = require("../../persistence/DiskWriter.cjs");
+const logger_js_1 = __importDefault(require("../../../utils/logger.cjs"));
+class DiskLogExporter extends wrappers_js_1.Enabler {
+    writer;
+    flushIntervalMs;
+    batchSize;
+    queuedLogs = [];
+    flushTimer = null;
+    flushing = false;
+    constructor(options) {
+        super();
+        this.flushIntervalMs = options.flushIntervalMs || 1000;
+        this.batchSize = options.batchSize || 500;
+        this.writer = new DiskWriter_js_1.DiskWriter({
+            directoryPath: options.directoryPath,
+            segmentPrefix: 'logs',
+            maxSegmentBytes: options.maxSegmentBytes,
+        });
+    }
+    export(logs, resultCallback) {
+        if (!this.isEnabled()) {
+            resultCallback({ code: core_1.ExportResultCode.SUCCESS });
+            return;
+        }
+        try {
+            const serializableLogs = logs
+                .map((logRecord) => this.formatLogRecord(logRecord))
+                .map((log) => (0, circular_js_1.removeCircularRefs)(log))
+                .map((log) => (0, circular_js_1.applyNesting)(log));
+            if (serializableLogs.length > 0) {
+                this.queuedLogs.push(...serializableLogs);
+                if (this.queuedLogs.length >= this.batchSize) {
+                    void this.flushPending();
+                }
+                else {
+                    this.scheduleFlush();
+                }
+            }
+            resultCallback({ code: core_1.ExportResultCode.SUCCESS });
+        }
+        catch (error) {
+            logger_js_1.default.error(`[DiskLogExporter] Failed to queue logs: ${error?.message || error}`);
+            resultCallback({
+                code: core_1.ExportResultCode.FAILED,
+                error: error instanceof Error ? error : new Error(String(error)),
+            });
+        }
+    }
+    async shutdown() {
+        this.disable();
+        if (this.flushTimer) {
+            clearTimeout(this.flushTimer);
+            this.flushTimer = null;
+        }
+        await this.flushPending(true);
+        await this.writer.flush();
+    }
+    async forceFlush() {
+        await this.flushPending(true);
+        await this.writer.flush();
+    }
+    scheduleFlush() {
+        if (this.flushTimer)
+            return;
+        this.flushTimer = setTimeout(() => {
+            this.flushTimer = null;
+            void this.flushPending(true);
+        }, this.flushIntervalMs);
+    }
+    async flushPending(forceAll = false) {
+        if (this.flushing)
+            return;
+        if (this.queuedLogs.length === 0)
+            return;
+        this.flushing = true;
+        try {
+            while (this.queuedLogs.length > 0) {
+                if (!forceAll && this.queuedLogs.length < this.batchSize) {
+                    this.scheduleFlush();
+                    break;
+                }
+                const size = forceAll ? this.queuedLogs.length : this.batchSize;
+                const batch = this.queuedLogs.splice(0, size);
+                await this.writer.appendRecords(batch);
+            }
+        }
+        catch (error) {
+            logger_js_1.default.error(`[DiskLogExporter] Failed writing logs to disk: ${error?.message || error}`);
+        }
+        finally {
+            this.flushing = false;
+        }
+    }
+    formatLogRecord(logRecord) {
+        return {
+            resource: {
+                attributes: logRecord.resource.attributes,
+            },
+            instrumentationScope: logRecord.instrumentationScope,
+            timestamp: (0, core_1.hrTimeToMicroseconds)(logRecord.hrTime) ?? Date.now(),
+            observedTimestamp: (0, core_1.hrTimeToMicroseconds)(logRecord.hrTimeObserved) ?? Date.now(),
+            traceId: logRecord.spanContext?.traceId,
+            spanId: logRecord.spanContext?.spanId,
+            traceFlags: logRecord.spanContext?.traceFlags,
+            severityText: logRecord.severityText,
+            severityNumber: logRecord.severityNumber,
+            body: logRecord.body,
+            attributes: logRecord.attributes,
+        };
+    }
+}
+exports.DiskLogExporter = DiskLogExporter;

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

@@ -0,0 +1,101 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiskMetricExporter = void 0;
+const core_1 = require("@opentelemetry/core");
+const circular_js_1 = require("../utils/circular.cjs");
+const wrappers_js_1 = require("../wrappers.cjs");
+const logger_js_1 = __importDefault(require("../../../utils/logger.cjs"));
+const DiskWriter_js_1 = require("../../persistence/DiskWriter.cjs");
+class DiskMetricExporter extends wrappers_js_1.Enabler {
+    writer;
+    flushIntervalMs;
+    batchSize;
+    queuedScopeMetrics = [];
+    flushTimer = null;
+    flushing = false;
+    constructor(options) {
+        super();
+        this.flushIntervalMs = options.flushIntervalMs || 1000;
+        this.batchSize = options.batchSize || 500;
+        this.writer = new DiskWriter_js_1.DiskWriter({
+            directoryPath: options.directoryPath,
+            segmentPrefix: 'metrics',
+            maxSegmentBytes: options.maxSegmentBytes,
+        });
+    }
+    export(resourceMetrics, resultCallback) {
+        if (!this.isEnabled()) {
+            resultCallback({ code: core_1.ExportResultCode.SUCCESS });
+            return;
+        }
+        try {
+            const scopeMetrics = (0, circular_js_1.removeCircularRefs)(resourceMetrics.scopeMetrics || []);
+            if (Array.isArray(scopeMetrics) && scopeMetrics.length > 0) {
+                this.queuedScopeMetrics.push(...scopeMetrics);
+                if (this.queuedScopeMetrics.length >= this.batchSize) {
+                    void this.flushPending();
+                }
+                else {
+                    this.scheduleFlush();
+                }
+            }
+            resultCallback({ code: core_1.ExportResultCode.SUCCESS });
+        }
+        catch (error) {
+            logger_js_1.default.error(`[DiskMetricExporter] Failed to queue scope metrics: ${error?.message || error}`);
+            resultCallback({
+                code: core_1.ExportResultCode.FAILED,
+                error: error instanceof Error ? error : new Error(String(error)),
+            });
+        }
+    }
+    async shutdown() {
+        this.disable();
+        if (this.flushTimer) {
+            clearTimeout(this.flushTimer);
+            this.flushTimer = null;
+        }
+        await this.flushPending(true);
+        await this.writer.flush();
+    }
+    async forceFlush() {
+        await this.flushPending(true);
+        await this.writer.flush();
+    }
+    scheduleFlush() {
+        if (this.flushTimer)
+            return;
+        this.flushTimer = setTimeout(() => {
+            this.flushTimer = null;
+            void this.flushPending(true);
+        }, this.flushIntervalMs);
+    }
+    async flushPending(forceAll = false) {
+        if (this.flushing)
+            return;
+        if (this.queuedScopeMetrics.length === 0)
+            return;
+        this.flushing = true;
+        try {
+            while (this.queuedScopeMetrics.length > 0) {
+                if (!forceAll && this.queuedScopeMetrics.length < this.batchSize) {
+                    this.scheduleFlush();
+                    break;
+                }
+                const size = forceAll ? this.queuedScopeMetrics.length : this.batchSize;
+                const batch = this.queuedScopeMetrics.splice(0, size);
+                await this.writer.appendRecords(batch);
+            }
+        }
+        catch (error) {
+            logger_js_1.default.error(`[DiskMetricExporter] Failed writing metrics to disk: ${error?.message || error}`);
+        }
+        finally {
+            this.flushing = false;
+        }
+    }
+}
+exports.DiskMetricExporter = DiskMetricExporter;

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

@@ -0,0 +1,103 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiskTraceExporter = void 0;
+const core_1 = require("@opentelemetry/core");
+const logger_js_1 = __importDefault(require("../../../utils/logger.cjs"));
+const circular_js_1 = require("../utils/circular.cjs");
+const DiskWriter_js_1 = require("../../persistence/DiskWriter.cjs");
+const wrappers_js_1 = require("../wrappers.cjs");
+class DiskTraceExporter extends wrappers_js_1.Enabler {
+    writer;
+    flushIntervalMs;
+    batchSize;
+    queuedSpans = [];
+    flushTimer = null;
+    flushing = false;
+    constructor(options) {
+        super();
+        this.flushIntervalMs = options.flushIntervalMs || 1000;
+        this.batchSize = options.batchSize || 500;
+        this.writer = new DiskWriter_js_1.DiskWriter({
+            directoryPath: options.directoryPath,
+            segmentPrefix: 'traces',
+            maxSegmentBytes: options.maxSegmentBytes,
+        });
+    }
+    export(spans, resultCallback) {
+        if (!this.isEnabled()) {
+            resultCallback({ code: core_1.ExportResultCode.SUCCESS });
+            return;
+        }
+        try {
+            const serializableSpans = spans
+                .map((span) => (0, circular_js_1.removeCircularRefs)(span))
+                .map((span) => (0, circular_js_1.applyNesting)(span));
+            if (serializableSpans.length > 0) {
+                this.queuedSpans.push(...serializableSpans);
+                if (this.queuedSpans.length >= this.batchSize) {
+                    void this.flushPending();
+                }
+                else {
+                    this.scheduleFlush();
+                }
+            }
+            resultCallback({ code: core_1.ExportResultCode.SUCCESS });
+        }
+        catch (error) {
+            logger_js_1.default.error(`[DiskTraceExporter] Failed to queue spans: ${error?.message || error}`);
+            resultCallback({
+                code: core_1.ExportResultCode.FAILED,
+                error: error instanceof Error ? error : new Error(String(error)),
+            });
+        }
+    }
+    async shutdown() {
+        this.disable();
+        if (this.flushTimer) {
+            clearTimeout(this.flushTimer);
+            this.flushTimer = null;
+        }
+        await this.flushPending(true);
+        await this.writer.flush();
+    }
+    async forceFlush() {
+        await this.flushPending(true);
+        await this.writer.flush();
+    }
+    scheduleFlush() {
+        if (this.flushTimer)
+            return;
+        this.flushTimer = setTimeout(() => {
+            this.flushTimer = null;
+            void this.flushPending(true);
+        }, this.flushIntervalMs);
+    }
+    async flushPending(forceAll = false) {
+        if (this.flushing)
+            return;
+        if (this.queuedSpans.length === 0)
+            return;
+        this.flushing = true;
+        try {
+            while (this.queuedSpans.length > 0) {
+                if (!forceAll && this.queuedSpans.length < this.batchSize) {
+                    this.scheduleFlush();
+                    break;
+                }
+                const size = forceAll ? this.queuedSpans.length : this.batchSize;
+                const batch = this.queuedSpans.splice(0, size);
+                await this.writer.appendRecords(batch);
+            }
+        }
+        catch (error) {
+            logger_js_1.default.error(`[DiskTraceExporter] Failed writing spans to disk: ${error?.message || error}`);
+        }
+        finally {
+            this.flushing = false;
+        }
+    }
+}
+exports.DiskTraceExporter = DiskTraceExporter;

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

@@ -12,36 +12,31 @@ const circular_js_1 = require("../utils/circular.cjs");
 const wrappers_js_1 = require("../wrappers.cjs");
 const logger_js_1 = __importDefault(require("../../../utils/logger.cjs"));
 const pluginService_js_1 = require("../../../tlm-plugin/pluginService.cjs");
-const storagePath_js_1 = require("../utils/storagePath.cjs");
 class InMemoryDbLogExporter extends wrappers_js_1.Enabler {
     _db = null;
     _miniSearch = null;
     _retentionTimeInSeconds;
-    _storagePath = null;
     _initialized = false;
     constructor(retentionTimeInSeconds = 3600) {
         super();
         this._retentionTimeInSeconds = retentionTimeInSeconds;
-        this._storagePath = (0, storagePath_js_1.getStoragePath)('logs');
         this._startCleanupJob();
     }
     _ensureInitialized() {
         if (this._initialized)
             return;
         this._initialized = true;
-        this._db = new nedb_1.default(this._storagePath ? { filename: this._storagePath, timestampData: true, autoload: true } : { timestampData: true });
-        this._db.ensureIndex({ fieldName: 'createdAt' });
+        this._db = new nedb_1.default();
+        this._db.ensureIndex({ fieldName: 'timestamp' });
         this._miniSearch = new minisearch_1.default({
             fields: ['body'],
             storeFields: ['_id'],
             idField: '_id',
         });
-        if (this._storagePath) {
-            logger_js_1.default.info(`[LogExporter] Disk storage enabled at: ${this._storagePath}`);
-        }
-        else {
-            logger_js_1.default.info(`[LogExporter] Using in-memory storage`);
-        }
+        logger_js_1.default.info(`[InMemoryDbLogExporter] In-memory storage created`);
+    }
+    initializeStorage() {
+        this._ensureInitialized();
     }
     /*
     * SUPER WARNING:
@@ -74,13 +69,13 @@ class InMemoryDbLogExporter extends wrappers_js_1.Enabler {
     }
     reset() {
         this._ensureInitialized();
-        // Remove all logs from database but keep persistence enabled
+        // Remove all logs from the in-memory database.
         this._db.remove({}, { multi: true }, (err) => {
             if (err) {
-                logger_js_1.default.error(`[LogExporter] Error during reset: ${err.message}`);
+                logger_js_1.default.error(`[InMemoryDbLogExporter] Error during reset: ${err.message}`);
             }
             else {
-                logger_js_1.default.info(`[LogExporter] Reset - all logs cleared`);
+                logger_js_1.default.info(`[InMemoryDbLogExporter] Reset - all logs cleared`);
             }
         });
         // Clear mini search index
@@ -106,7 +101,7 @@ class InMemoryDbLogExporter extends wrappers_js_1.Enabler {
         if (messageSearch) {
             const searchResults = this._miniSearch.search(messageSearch, { prefix: true, fuzzy: 0.2 });
             const ids = searchResults.map((result) => result._id);
-            logger_js_1.default.debug(`MiniSearch found ${ids.length} results for search term "${messageSearch}"`, { depth: 3 });
+            logger_js_1.default.debug(`[InMemoryDbLogExporter] MiniSearch found ${ids.length} results for search term "${messageSearch}"`, { depth: 3 });
             finalQuery._id = { $in: ids };
         }
         const docs = await new Promise((resolve, reject) => {
@@ -130,7 +125,7 @@ class InMemoryDbLogExporter extends wrappers_js_1.Enabler {
             if (result.code === core_2.ExportResultCode.SUCCESS) {
                 this._db.find({}, (err, docs) => {
                     if (err) {
-                        logger_js_1.default.debug(err);
+                        logger_js_1.default.debug('[InMemoryDbLogExporter] Error fetching inserted logs', err);
                         callback(err, []);
                         return;
                     }
@@ -171,7 +166,7 @@ class InMemoryDbLogExporter extends wrappers_js_1.Enabler {
     }
     set retentionTimeInSeconds(retentionTimeInSeconds) {
         this._retentionTimeInSeconds = retentionTimeInSeconds;
-        logger_js_1.default.info(`InMemoryDbLogExporter retention time set to ${this._retentionTimeInSeconds} seconds`);
+        logger_js_1.default.info(`[InMemoryDbLogExporter] Retention time set to ${this._retentionTimeInSeconds} seconds`);
     }
     get retentionTimeInSeconds() {
         return this._retentionTimeInSeconds;
@@ -199,10 +194,10 @@ class InMemoryDbLogExporter extends wrappers_js_1.Enabler {
             const expirationDate = new Date(Date.now() - this._retentionTimeInSeconds * 1000);
             this._db.remove({ createdAt: { $lt: expirationDate } }, { multi: true }, (err, numRemoved) => {
                 if (err) {
-                    logger_js_1.default.error('Error in TTL cleanup:', err);
+                    logger_js_1.default.error('[InMemoryDbLogExporter] Error in TTL cleanup:', err);
                 }
                 else if (numRemoved > 0) {
-                    logger_js_1.default.debug(`TTL cleanup: removed ${numRemoved} expired logs`);
+                    logger_js_1.default.debug(`[InMemoryDbLogExporter] TTL cleanup removed ${numRemoved} expired logs`);
                 }
             });
         }, interval);