@oas-tools/oas-telemetry 0.6.2 → 0.7.0-alpha.1

package/{src/routes → dist/esm/tlm-metric}/metricsRoutes.js

@@ -1,15 +1,8 @@
-import { Router } from 'express';
-import {
-    listMetrics,
-    findMetrics,
-    resetMetrics
-} from '../controllers/metricsController.js';
-
-export const metricsRoutes = Router();
-
-// Metrics Control
-metricsRoutes.get('/', listMetrics);
-metricsRoutes.post('/find', findMetrics);
-metricsRoutes.get('/reset', resetMetrics);
-
-export default metricsRoutes;
+import { Router } from 'express';
+import { listMetrics, findMetrics, resetMetrics } from './metricsController.js';
+export const metricsRoutes = Router();
+// Metrics Control
+metricsRoutes.get('/', listMetrics);
+metricsRoutes.post('/find', findMetrics);
+metricsRoutes.get('/reset', resetMetrics);
+export default metricsRoutes;

package/{src/controllers → dist/esm/tlm-plugin}/pluginController.js

@@ -1,115 +1,103 @@
-
-import { globalOasTlmConfig } from '../config.js';
-import axios from 'axios';
-import { importFromString, requireFromString } from 'import-from-string';
-import { installDependencies } from 'dynamic-installer';
-
-let dbglog = () => { };
-
-if (process.env.OTDEBUG == "true")
-    dbglog = console.log;
-export const listPlugins = (req, res) => {
-    res.send(globalOasTlmConfig.dynamicExporter.getPlugins().map((p) => {
-        return {
-            id: p.id,
-            name: p.name,
-            url: p.url,
-            active: p.active
-        };
-    }));
-}
-
-export const registerPlugin = async (req, res) => {
-    let pluginResource = req.body;
-    dbglog(`Plugin Registration Request: = ${JSON.stringify(req.body, null, 2)}...`);
-    dbglog(`Getting plugin at ${pluginResource.url}...`);
-    let pluginCode;
-    if (!pluginResource.url && !pluginResource.code) {
-        res.status(400).send(`Plugin code or URL must be provided`);
-        return;
-    }
-
-    let module;
-    try {
-        if (pluginResource.code) {
-            pluginCode = pluginResource.code
-        } else {
-            const response = await axios.get(pluginResource.url);
-            pluginCode = response.data;
-        }
-        if (!pluginCode) {
-            res.status(400).send(`Plugin code could not be loaded`);
-            return;
-        }
-        if (pluginResource.install) {
-            const dependenciesStatus = await installDependencies(pluginResource.install);
-            if (!dependenciesStatus.success) {
-                if (pluginResource.install.ignoreErrors === true) {
-                    console.warn(`Warning: Error installing dependencies: ${JSON.stringify(dependenciesStatus.details)}`);
-                } else {
-                    res.status(400).send(`Error installing dependencies: ${JSON.stringify(dependenciesStatus.details)}`);
-                    return;
-                }
-            }
-        }
-
-        dbglog("Plugin size: " + pluginCode?.length);
-        dbglog("Plugin format: " + pluginResource?.moduleFormat);
-        if (pluginResource?.moduleFormat && pluginResource.moduleFormat.toUpperCase() == "ESM") {
-            console.log("ESM detected")
-            module = await importFromString(pluginCode)
-        } else {
-            console.log("CJS detected (default)")
-            module = await requireFromString(pluginCode)
-            console.log(module)
-        }
-    } catch (error) {
-        console.error(`Error loading plugin: ${error}`);
-        res.status(400).send(`Error loading plugin: ${error}`);
-        return;
-    }
-
-    const plugin = module.default?.plugin ?? module.plugin;
-
-    if (plugin == undefined) {
-        res.status(400).send(`Plugin code should export a "plugin" object`);
-        console.log("Error in plugin code: no plugin object exported");
-        return;
-    }
-    for (let requiredFunction of ["load", "getName", "isConfigured"]) {
-        if (plugin[requiredFunction] == undefined) {
-            res.status(400).send(`The plugin code exports a "plugin" object, however it should have a "${requiredFunction}" method`);
-            console.log("Error in plugin code: some required functions are missing");
-            return;
-        }
-    }
-
-    try {
-        await plugin.load(pluginResource.config);
-    } catch (error) {
-        console.error(`Error loading plugin configuration: ${error}`);
-        res.status(400).send(`Error loading plugin configuration: ${error}`);
-        return;
-    }
-    if (plugin.isConfigured()) {
-        dbglog(`Loaded plugin <${plugin.getName()}>`);
-        pluginResource.plugin = plugin;
-        pluginResource.name = plugin.getName();
-        pluginResource.active = true;
-        globalOasTlmConfig.dynamicExporter.pushPlugin(pluginResource);
-        globalOasTlmConfig.dynamicExporter.activatePlugin(pluginResource.plugin);
-        res.status(201).send(`Plugin registered`);
-    } else {
-        console.error(`Plugin <${plugin.getName()}> can not be configured`);
-        res.status(400).send(`Plugin configuration problem`);
-    }
-}
-
-export const checkApiKey = (req, res) => {
-    const apiKey = req.query.apiKey || req.body.apiKey;
-    if (apiKey === process.env.APIKEY) {
-        res.status(200).send({ valid: true });
-    } else {
-        res.status(401).send({ valid: false });
-    }
-}
+import { globalOasTlmConfig } from '../config.js';
+import axios from 'axios';
+// @ts-expect-error: import-from-string does not have proper type declarations
+import { importFromString, requireFromString } from 'import-from-string';
+// @ts-expect-error: dynamic-installer does not have proper type declarations
+import { installDependencies } from 'dynamic-installer';
+import logger from '../utils/logger.js';
+export const listPlugins = (req, res) => {
+    res.send(globalOasTlmConfig.dynamicSpanExporter.getPlugins().map((plugin) => {
+        return {
+            id: plugin.id,
+            name: plugin.name,
+            url: plugin.url,
+            active: plugin.active
+        };
+    }));
+};
+export const registerPlugin = async (req, res) => {
+    const pluginResource = req.body;
+    logger.info(`Plugin Registration Request: = ${JSON.stringify(req.body, null, 2)}...`);
+    logger.info(`Getting plugin at ${pluginResource.url}...`);
+    let pluginCode;
+    if (!pluginResource.url && !pluginResource.code) {
+        res.status(400).send(`Plugin code or URL must be provided`);
+        return;
+    }
+    let module;
+    try {
+        if (pluginResource.code) {
+            pluginCode = pluginResource.code;
+        }
+        else {
+            const response = await axios.get(pluginResource.url);
+            pluginCode = response.data;
+        }
+        if (!pluginCode) {
+            res.status(400).send(`Plugin code could not be loaded`);
+            return;
+        }
+        if (pluginResource.install) {
+            const dependenciesStatus = await installDependencies(pluginResource.install);
+            if (!dependenciesStatus.success) {
+                if (pluginResource.install.ignoreErrors === true) {
+                    logger.warn(`Warning: Error installing dependencies: ${JSON.stringify(dependenciesStatus.details)}`);
+                }
+                else {
+                    res.status(400).send(`Error installing dependencies: ${JSON.stringify(dependenciesStatus.details)}`);
+                    return;
+                }
+            }
+        }
+        logger.info("Plugin size: " + pluginCode?.length);
+        logger.info("Plugin format: " + pluginResource?.moduleFormat);
+        if (pluginResource?.moduleFormat && pluginResource.moduleFormat.toUpperCase() == "ESM") {
+            logger.info("ESM detected");
+            module = await importFromString(pluginCode);
+        }
+        else {
+            logger.info("CJS detected (default)");
+            module = await requireFromString(pluginCode);
+            logger.info(module);
+        }
+    }
+    catch (error) {
+        logger.error(`Error loading plugin: ${error}`);
+        res.status(400).send(`Error loading plugin: ${error}`);
+        return;
+    }
+    const plugin = module.default?.plugin ?? module.plugin;
+    if (plugin == undefined) {
+        res.status(400).send(`Plugin code should export a "plugin" object`);
+        logger.info("Error in plugin code: no plugin object exported");
+        return;
+    }
+    for (const requiredFunction of ["load", "getName", "isConfigured"]) {
+        if (plugin[requiredFunction] == undefined) {
+            res.status(400).send(`The plugin code exports a "plugin" object, however it should have a "${requiredFunction}" method`);
+            logger.info("Error in plugin code: some required functions are missing");
+            return;
+        }
+    }
+    try {
+        await plugin.load(pluginResource.config);
+    }
+    catch (error) {
+        logger.error(`Error loading plugin configuration: ${error}`);
+        res.status(400).send(`Error loading plugin configuration: ${error}`);
+        return;
+    }
+    if (plugin.isConfigured()) {
+        logger.info(`Loaded plugin <${plugin.getName()}>`);
+        pluginResource.plugin = plugin;
+        pluginResource.name = plugin.getName();
+        pluginResource.active = true;
+        globalOasTlmConfig.dynamicSpanExporter.pushPlugin(pluginResource);
+        globalOasTlmConfig.dynamicSpanExporter.activatePlugin(pluginResource.plugin);
+        res.status(201).send(`Plugin registered`);
+    }
+    else {
+        logger.error(`Plugin <${plugin.getName()}> can not be configured`);
+        res.status(400).send(`Plugin configuration problem`);
+    }
+};

package/dist/esm/tlm-plugin/pluginRoutes.js

@@ -0,0 +1,7 @@
+import { Router } from 'express';
+import { listPlugins, registerPlugin } from './pluginController.js';
+export const pluginRoutes = Router();
+// Plugins
+pluginRoutes.get('/plugins', listPlugins);
+pluginRoutes.post('/plugins', registerPlugin);
+export default pluginRoutes;

package/dist/esm/tlm-trace/traceController.js

@@ -0,0 +1,54 @@
+import { globalOasTlmConfig } from '../config.js';
+export const startTelemetry = (req, res) => {
+    globalOasTlmConfig.dynamicSpanExporter.exporter.start();
+    res.send('Telemetry started');
+};
+export const stopTelemetry = (req, res) => {
+    globalOasTlmConfig.dynamicSpanExporter.exporter.stop();
+    res.send('Telemetry stopped');
+};
+export const statusTelemetry = (req, res) => {
+    const isRunning = globalOasTlmConfig.dynamicSpanExporter.exporter.isRunning() || false;
+    res.send({ active: isRunning });
+};
+export const resetTelemetry = (req, res) => {
+    globalOasTlmConfig.dynamicSpanExporter.exporter.reset();
+    res.send('Telemetry reset');
+};
+export const listTelemetry = async (req, res) => {
+    try {
+        const spans = await globalOasTlmConfig.dynamicSpanExporter.exporter.getFinishedSpans();
+        res.send({ spansCount: spans.length, spans: spans });
+    }
+    catch (err) {
+        console.error(err);
+        res.status(500).send({ error: 'Failed to list telemetry data' });
+    }
+};
+export const findTelemetry = (req, res) => {
+    const body = req.body;
+    const search = body?.search ? body.search : {};
+    if (body?.flags?.containsRegex) {
+        try {
+            //@ts-expect-error yes
+            body.config?.regexIds?.forEach(regexId => {
+                if (search[regexId])
+                    search[regexId] = new RegExp(search[regexId]);
+            });
+        }
+        catch (e) {
+            console.error(e);
+            res.status(404).send({ spansCount: 0, spans: [], error: e });
+            return;
+        }
+    }
+    globalOasTlmConfig.dynamicSpanExporter.exporter.find(search, (err, docs) => {
+        if (err) {
+            console.error(err);
+            res.status(404).send({ spansCount: 0, spans: [], error: err });
+            return;
+        }
+        const spans = docs;
+        res.send({ spansCount: spans.length, spans: spans });
+    });
+};

package/dist/esm/tlm-trace/traceRoutes.js

@@ -0,0 +1,11 @@
+import { Router } from 'express';
+import { startTelemetry, stopTelemetry, statusTelemetry, resetTelemetry, listTelemetry, findTelemetry } from './traceController.js';
+export const traceRoutes = Router();
+traceRoutes.get('/', listTelemetry);
+traceRoutes.post('/find', findTelemetry);
+// Telemetry Control
+traceRoutes.get('/start', startTelemetry);
+traceRoutes.get('/stop', stopTelemetry);
+traceRoutes.get('/status', statusTelemetry);
+traceRoutes.get('/reset', resetTelemetry);
+export default traceRoutes;

package/dist/esm/tlm-ui/uiRoutes.js

@@ -0,0 +1,23 @@
+import express, { Router } from 'express';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import logger from '../utils/logger.js';
+let relativePath = '../../ui';
+if (process.env.OASTLM_ENV === 'development') {
+    relativePath = '../../dist/ui';
+    logger.warn('🚧 This process is serving the OASTLM UI from the build directory, but you are in development mode. For live updates, run the React app separately and access it at http://localhost:5173/.');
+}
+const customFilename = fileURLToPath(import.meta.url);
+const customDirname = path.dirname(customFilename);
+const staticFilesPath = path.join(customDirname, relativePath);
+export const uiRoutes = Router();
+// This only works once the app is built: src/ --> dist/esm/
+// This file: dist/esm/routes/
+// UI bundle: dist/ui/
+// For development, the UI is served separately.
+uiRoutes.use(express.static(staticFilesPath));
+uiRoutes.get('*', (_req, res) => {
+    // Serve the index.html file for all routes
+    res.sendFile(path.join(staticFilesPath, 'index.html'));
+});
+export default uiRoutes;

package/dist/esm/tlm-util/utilController.js

@@ -0,0 +1,57 @@
+import { globalOasTlmConfig } from '../config.js';
+import { readFileSync } from 'fs';
+import path from 'path';
+import yaml from 'js-yaml';
+import v8 from 'node:v8';
+export const specLoader = (_req, res) => {
+    if (globalOasTlmConfig.specFileName) {
+        try {
+            const data = readFileSync(globalOasTlmConfig.specFileName, { encoding: 'utf8', flag: 'r' });
+            const extension = path.extname(globalOasTlmConfig.specFileName);
+            let json = data;
+            if (extension == "yaml")
+                //@ts-expect-error yes
+                json = JSON.stringify(yaml.SafeLoad(data), null, 2);
+            res.setHeader('Content-Type', 'application/json');
+            res.send(json);
+        }
+        catch (e) {
+            console.error(`ERROR loading spec file ${globalOasTlmConfig.specFileName}: ${e}`);
+        }
+    }
+    else if (globalOasTlmConfig.spec) {
+        let spec = null;
+        try {
+            spec = JSON.parse(globalOasTlmConfig.spec);
+        }
+        catch (ej) {
+            try {
+                spec = JSON.stringify(yaml.load(globalOasTlmConfig.spec), null, 2);
+            }
+            catch (ey) {
+                console.error(`Error parsing spec: ${ej} - ${ey}`);
+            }
+        }
+        if (!spec) {
+            res.status(404);
+        }
+        else {
+            res.setHeader('Content-Type', 'application/json');
+            res.send(spec);
+        }
+    }
+    else {
+        res.status(404);
+    }
+};
+export const heapStats = (req, res) => {
+    const heapStats = v8.getHeapStatistics();
+    const roundedHeapStats = Object.getOwnPropertyNames(heapStats).reduce(function (map, stat) {
+        //@ts-expect-error yes
+        map[stat] = Math.round((heapStats[stat] / 1024 / 1024) * 1000) / 1000;
+        return map;
+    }, {});
+    // @ts-expect-error yes
+    roundedHeapStats['units'] = 'MB';
+    res.send(roundedHeapStats);
+};

package/dist/esm/tlm-util/utilRoutes.js

@@ -0,0 +1,6 @@
+import { Router } from 'express';
+import { specLoader, heapStats } from './utilController.js';
+export const utilsRoutes = Router();
+utilsRoutes.get('/spec', specLoader);
+utilsRoutes.get('/heapStats', heapStats);
+export default utilsRoutes;

package/dist/esm/tlmRoutes.js

@@ -0,0 +1,72 @@
+import { json } from "express";
+import logger from "./utils/logger.js";
+import cors from 'cors';
+import { globalOasTlmConfig } from "./config.js";
+import metricsRoutes from "./tlm-metric/metricsRoutes.js";
+import cookieParser from 'cookie-parser';
+import authRoutes from './tlm-auth/authRoutes.js';
+import uiRoutes from './tlm-ui/uiRoutes.js';
+import traceRoutes from "./tlm-trace/traceRoutes.js";
+import { authMiddleware } from "./tlm-auth/authMiddleware.js";
+import utilsRoutes from "./tlm-util/utilRoutes.js";
+import logRoutes from './tlm-log/logRoutes.js';
+import aiRoutes from "./tlm-ai/aiRoutes.js";
+export const configureRoutes = (router) => {
+    if (process.env.OASTLM_ENV === 'development') {
+        logger.info("Running in development mode, enabling CORS for all origins");
+        router.use(cors({
+            origin: '*', // Permitir todas las solicitudes en desarrollo
+            methods: ['GET', 'POST', 'PUT', 'DELETE'],
+            allowedHeaders: ['Content-Type', 'Authorization'],
+        }));
+    }
+    router.use((req, res, next) => {
+        if (req.body !== undefined) {
+            return next(); // Already parsed, no need to parse again.
+        }
+        return json()(req, res, next);
+    });
+    const allAuthMiddlewares = getWrappedMiddlewares(() => globalOasTlmConfig.authEnabled, [cookieParser(), authRoutes, authMiddleware]);
+    const baseURL = globalOasTlmConfig.baseURL;
+    router.use(baseURL, allAuthMiddlewares);
+    // WARNING: This path must be the same as the one used in the UI package App.tsx "oas-telemetry-ui"
+    router.use(baseURL + "/traces", traceRoutes);
+    router.use(baseURL + "/metrics", metricsRoutes);
+    router.use(baseURL + "/logs", logRoutes);
+    router.use(baseURL + "/ai", getWrappedMiddlewares(() => process.env.OASTLM_AI_OPENAI_API_KEY !== null && process.env.OASTLM_AI_OPENAI_API_KEY !== "", [aiRoutes]));
+    router.use(baseURL + "/oas-telemetry-ui", uiRoutes);
+    router.use(baseURL + "/utils", utilsRoutes);
+    //redirect to the UI when accessing the base URL
+    router.get(baseURL, (req, res) => {
+        res.redirect(baseURL + "/oas-telemetry-ui");
+    });
+};
+/**
+ * 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.
+ */
+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();
+            }
+        };
+    });
+}

package/dist/esm/types/index.js

@@ -0,0 +1,4 @@
+;
+;
+;
+export {};

package/dist/esm/utils/circular.js

@@ -0,0 +1,84 @@
+export function removeCircularRefs(obj) {
+    // const seen = new WeakMap(); // Used to keep track of visited objects
+    // Replacer function to handle circular references
+    function replacer(key, value) {
+        if (key === "_spanProcessor") {
+            return "oas-telemetry skips this field to avoid circular reference";
+        }
+        // GENERIC CIRCULAR REFERENCE HANDLING
+        // if (typeof value === "object" && value !== null) {
+        //     // If the object has been visited before, return the name prefixed with "CIRCULAR+"
+        //     if (seen.has(value)) {
+        //         return `CIRCULAR${key}`;
+        //     }
+        //     seen.set(value, key); // Mark the object as visited with its name
+        // }
+        return value;
+    }
+    // Convert the object to a string and then parse it back
+    // This will trigger the replacer function to handle circular references
+    const jsonString = JSON.stringify(obj, replacer);
+    return JSON.parse(jsonString);
+}
+/**
+ * Recursively converts dot-separated keys in an object to nested objects.
+ *
+ * @param {any} obj - The object to process.
+ * @returns {any} - The object with all dot-separated keys converted to nested objects.
+ * @example
+ * // Input:
+ * // {
+ * //   "http.method": "GET",
+ * //   "http.url": "http://example.com",
+ * //   "nested.obj.key": "value"
+ * // }
+ * // Output:
+ * // {
+ * //   "http": {
+ * //     "method": "GET",
+ * //     "url": "http://example.com"
+ * //   },
+ * //   "nested": {
+ * //     "obj": {
+ * //       "key": "value"
+ * //     }
+ * //   }
+ * // }
+ */
+export function convertToNestedObject(obj) {
+    const result = {};
+    for (const key in obj) {
+        const keys = key.split('.');
+        let temp = result;
+        for (let i = 0; i < keys.length; i++) {
+            const currentKey = keys[i];
+            if (i === keys.length - 1) {
+                // Last key, set the value
+                temp[currentKey] = obj[key];
+            }
+            else {
+                // Intermediate key, ensure the object exists
+                if (!temp[currentKey]) {
+                    temp[currentKey] = {};
+                }
+                temp = temp[currentKey];
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Applies nesting to all dot-separated keys within an object.
+ */
+export function applyNesting(obj) {
+    for (const key in obj) {
+        const value = obj[key];
+        if (Array.isArray(value)) {
+            obj[key] = value.map(item => typeof item === 'object' && item !== null ? applyNesting(item) : item);
+        }
+        else if (typeof value === 'object' && value !== null) {
+            obj[key] = applyNesting(value);
+        }
+    }
+    return convertToNestedObject(obj);
+}

package/dist/esm/utils/logger.js

@@ -0,0 +1,19 @@
+import dotenv from 'dotenv';
+dotenv.config();
+const LOG_LEVELS = ['DEBUG', 'INFO', 'WARN', 'ERROR', 'NONE'];
+const currentLogLevel = (process.env.OASTLM_LOG_LEVEL || 'INFO').toUpperCase();
+const serviceName = process.env.OASTLM_SERVICE_NAME || 'OAS-TLM';
+function log(level, ...messages) {
+    if (LOG_LEVELS.indexOf(level) >= LOG_LEVELS.indexOf(currentLogLevel)) {
+        const timestamp = new Date().toISOString();
+        console.log(`${timestamp} [${serviceName}] [${level}]:`, ...messages);
+    }
+}
+export default {
+    debug: (...messages) => log('DEBUG', ...messages),
+    info: (...messages) => log('INFO', ...messages),
+    log: (...messages) => log('INFO', ...messages), // Alias for info
+    warn: (...messages) => log('WARN', ...messages),
+    error: (...messages) => log('ERROR', ...messages),
+    currentLogLevel
+};

package/dist/types/config.d.ts

@@ -0,0 +1,6 @@
+import { type GlobalOasTlmConfig } from "./types/index.js";
+export declare const globalOasTlmConfig: GlobalOasTlmConfig;
+declare const _default: {
+    globalOasTlmConfig: GlobalOasTlmConfig;
+};
+export default _default;

package/dist/types/exporters/InMemoryDBMetricsExporter.d.ts

@@ -0,0 +1,15 @@
+import { ResourceMetrics } from '@opentelemetry/sdk-metrics';
+export declare class InMemoryDBMetricsExporter {
+    private _metrics;
+    private _stopped;
+    constructor();
+    export(metrics: ResourceMetrics, resultCallback: any): any;
+    start(): void;
+    stop(): void;
+    isRunning(): boolean;
+    shutdown(): Promise<void>;
+    forceFlush(): Promise<void>;
+    find(search: any, callback: any): void;
+    reset(): void;
+    getFinishedMetrics(): import("@seald-io/nedb").Document<Record<string, any>>[];
+}

package/dist/types/exporters/InMemoryDbExporter.d.ts

@@ -0,0 +1,24 @@
+import { ExportResultCode } from '@opentelemetry/core';
+import { ReadableSpan } from '@opentelemetry/sdk-trace-base';
+import { OasTlmExporter, PluginResource } from '../types/index.js';
+export declare class InMemoryExporter implements OasTlmExporter {
+    private _spans;
+    private _stopped;
+    constructor();
+    plugins: PluginResource[];
+    export(readableSpans: ReadableSpan[], resultCallback: (arg0: {
+        code: ExportResultCode;
+        error?: Error;
+    }) => void): void;
+    start(): void;
+    stop(): void;
+    isRunning(): boolean;
+    shutdown(): Promise<void>;
+    /**
+     * Exports any pending spans in the exporter
+     */
+    forceFlush(): Promise<void>;
+    find(search: any, callback: any): void;
+    reset(): void;
+    getFinishedSpans(): import("@seald-io/nedb").Document<Record<string, any>>[];
+}