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

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

@@ -1,13 +1,12 @@
-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) {
+export const specLoader = (_req, res, oasTlmConfig) => {
+    if (oasTlmConfig.general.specFileName) {
         try {
-            const data = readFileSync(globalOasTlmConfig.specFileName, { encoding: 'utf8', flag: 'r' });
-            const extension = path.extname(globalOasTlmConfig.specFileName);
+            const data = readFileSync(oasTlmConfig.general.specFileName, { encoding: 'utf8', flag: 'r' });
+            const extension = path.extname(oasTlmConfig.general.specFileName);
             let json = data;
             if (extension == "yaml")
                 //@ts-expect-error yes
@@ -16,17 +15,17 @@ export const specLoader = (_req, res) => {
             res.send(json);
         }
         catch (e) {
-            console.error(`ERROR loading spec file ${globalOasTlmConfig.specFileName}: ${e}`);
+            console.error(`ERROR loading spec file ${oasTlmConfig.general.specFileName}: ${e}`);
         }
     }
-    else if (globalOasTlmConfig.spec) {
+    else if (oasTlmConfig.general.spec) {
         let spec = null;
         try {
-            spec = JSON.parse(globalOasTlmConfig.spec);
+            spec = JSON.parse(oasTlmConfig.general.spec);
         }
         catch (ej) {
             try {
-                spec = JSON.stringify(yaml.load(globalOasTlmConfig.spec), null, 2);
+                spec = JSON.stringify(yaml.load(oasTlmConfig.general.spec), null, 2);
             }
             catch (ey) {
                 console.error(`Error parsing spec: ${ej} - ${ey}`);

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

@@ -1,17 +1,19 @@
 import { Router } from 'express';
 import { specLoader, heapStats } from './utilController.js';
-export const utilsRoutes = Router();
-utilsRoutes.get('/spec', specLoader);
-utilsRoutes.get('/heapStats', heapStats);
-utilsRoutes.get('/generateLog', (req, res) => {
-    const log = req.query.log || 'Default log message';
-    console.log('Generated log:', log);
-    res.send({ message: 'Log generated', log: log });
-});
-utilsRoutes.get('/wait/:seconds?', async (req, res) => {
-    const seconds = parseInt(req.params.seconds ?? "1", 10);
-    const waitTime = isNaN(seconds) ? 1 : seconds;
-    await new Promise(resolve => setTimeout(resolve, waitTime * 1000));
-    res.send({ waited: waitTime });
-});
-export default utilsRoutes;
+export const getUtilsRoutes = (oasTlmConfig) => {
+    const router = Router();
+    router.get('/spec', (req, res) => specLoader(req, res, oasTlmConfig));
+    router.get('/heapStats', heapStats);
+    router.get('/generateLog', (req, res) => {
+        const log = req.query.log || 'Default log message';
+        console.log(log);
+        res.send({ message: 'Log generated', log: log });
+    });
+    router.get('/wait/:seconds?', async (req, res) => {
+        const seconds = parseInt(req.params.seconds ?? "1", 10);
+        const waitTime = isNaN(seconds) ? 1 : seconds;
+        await new Promise(resolve => setTimeout(resolve, waitTime * 1000));
+        res.send({ waited: waitTime });
+    });
+    return router;
+};

package/dist/esm/types/index.js

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

package/dist/esm/utils/logger.js

@@ -1,8 +1,7 @@
-import dotenv from 'dotenv';
-dotenv.config();
+import { bootEnvVariables } from "../config/bootConfig.js";
 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';
+const currentLogLevel = (bootEnvVariables.OASTLM_BOOT_LOG_LEVEL || 'INFO').toUpperCase();
+const serviceName = 'OAS-Telemetry';
 function log(level, ...messages) {
     if (LOG_LEVELS.indexOf(level) >= LOG_LEVELS.indexOf(currentLogLevel)) {
         const timestamp = new Date().toISOString();

package/dist/esm/utils/regexUtils.js

@@ -0,0 +1,23 @@
+export const convertRegexRecursively = (obj) => {
+    if (Array.isArray(obj)) {
+        return obj.map(convertRegexRecursively);
+    }
+    else if (obj && typeof obj === 'object') {
+        const newObj = {};
+        for (const key of Object.keys(obj)) {
+            if (key === '$regex' && typeof obj[key] === 'string') {
+                try {
+                    return new RegExp(obj[key]);
+                }
+                catch {
+                    throw new Error(`Invalid regex value "${obj[key]}"`);
+                }
+            }
+            else {
+                newObj[key] = convertRegexRecursively(obj[key]);
+            }
+        }
+        return newObj;
+    }
+    return obj;
+};

package/dist/types/config/bootConfig.d.ts

@@ -0,0 +1,5 @@
+export declare const bootEnvVariables: {
+    OASTLM_BOOT_ENV: string;
+    OASTLM_BOOT_MODULE_DISABLED: boolean;
+    OASTLM_BOOT_LOG_LEVEL: string;
+};

package/dist/types/config/config.d.ts

@@ -0,0 +1,253 @@
+import { OasTlmConfig, DeepPartial, UserConfig } from './config.types';
+import { BufferConfig, SpanExporter, SpanProcessor } from '@opentelemetry/sdk-trace-node';
+import { IMetricReader, MetricProducer } from '@opentelemetry/sdk-metrics';
+import { LogRecordExporter, LogRecordProcessor } from '@opentelemetry/sdk-logs';
+import { type PluginResource } from '../types/index.js';
+import { ViewOptions } from '@opentelemetry/sdk-metrics/build/src/view/View';
+export declare const defaultConfig: {
+    general: {
+        baseUrl: string;
+        specFileName: string | null;
+        spec: string | null;
+        uiPath: string;
+    };
+    auth: {
+        enabled: boolean;
+        apiKeyMaxAge: number;
+        password: string;
+        jwtSecret: string;
+    };
+    ai: {
+        openAIKey: string | null;
+        openAIModel: string;
+        extraContextPrompts: string[];
+    };
+    traces: {
+        extraExporters: SpanExporter[];
+        extraProcessors: SpanProcessor[];
+        mainProcessorOptions: {
+            config: BufferConfig | undefined;
+        };
+        memoryExporter: {
+            enabled: boolean;
+            retentionTimeSeconds: number;
+        };
+        filters: any[];
+    };
+    metrics: {
+        mainMetricReaderOptions: {
+            exportIntervalMillis: number;
+            metricProducers: MetricProducer[];
+        };
+        extraReaders: IMetricReader[];
+        extraViews: ViewOptions[];
+        memoryExporter: {
+            enabled: boolean;
+            retentionTimeSeconds: number;
+        };
+        filters: any[];
+    };
+    logs: {
+        extraExporters: LogRecordExporter[];
+        extraProcessors: LogRecordProcessor[];
+        memoryExporter: {
+            enabled: boolean;
+            retentionTimeSeconds: number;
+        };
+        filters: any[];
+    };
+    plugins: {
+        enabled: boolean;
+        extraPlugins: PluginResource[];
+    };
+};
+export declare const getConfig: (userConfig?: UserConfig, fallbackConfig?: OasTlmConfig, envConfig?: DeepPartial<OasTlmConfig>) => {
+    general: {
+        baseUrl: string;
+        specFileName: string | null;
+        spec: string | null;
+        uiPath: string;
+    };
+    auth: {
+        enabled: boolean;
+        apiKeyMaxAge: number;
+        password: string;
+        jwtSecret: string;
+    };
+    ai: {
+        openAIKey: string | null;
+        openAIModel: string;
+        extraContextPrompts: string[];
+    };
+    traces: {
+        extraExporters: SpanExporter[];
+        extraProcessors: SpanProcessor[];
+        mainProcessorOptions: {
+            config: BufferConfig | undefined;
+        };
+        memoryExporter: {
+            enabled: boolean;
+            retentionTimeSeconds: number;
+        };
+        filters: any[];
+    };
+    metrics: {
+        mainMetricReaderOptions: {
+            exportIntervalMillis: number;
+            metricProducers: MetricProducer[];
+        };
+        extraReaders: IMetricReader[];
+        extraViews: ViewOptions[];
+        memoryExporter: {
+            enabled: boolean;
+            retentionTimeSeconds: number;
+        };
+        filters: any[];
+    };
+    logs: {
+        extraExporters: LogRecordExporter[];
+        extraProcessors: LogRecordProcessor[];
+        memoryExporter: {
+            enabled: boolean;
+            retentionTimeSeconds: number;
+        };
+        filters: any[];
+    };
+    plugins: {
+        enabled: boolean;
+        extraPlugins: PluginResource[];
+    };
+} & UserConfig & {
+    general?: {
+        baseUrl?: string | undefined;
+        specFileName?: string | null | undefined;
+        spec?: string | null | undefined;
+        uiPath?: string | undefined;
+    } | undefined;
+    auth?: {
+        enabled?: boolean | undefined;
+        apiKeyMaxAge?: number | undefined;
+        password?: string | undefined;
+        jwtSecret?: string | undefined;
+    } | undefined;
+    ai?: {
+        openAIKey?: string | null | undefined;
+        openAIModel?: string | undefined;
+        extraContextPrompts?: (string | undefined)[] | undefined;
+    } | undefined;
+    traces?: {
+        extraExporters?: ({
+            export?: {} | undefined;
+            shutdown?: {} | undefined;
+            forceFlush?: {} | undefined;
+        } | undefined)[] | undefined;
+        extraProcessors?: ({
+            forceFlush?: {} | undefined;
+            onStart?: {} | undefined;
+            onEnd?: {} | undefined;
+            shutdown?: {} | undefined;
+        } | undefined)[] | undefined;
+        mainProcessorOptions?: {
+            config?: {
+                maxExportBatchSize?: number | undefined;
+                scheduledDelayMillis?: number | undefined;
+                exportTimeoutMillis?: number | undefined;
+                maxQueueSize?: number | undefined;
+            } | undefined;
+        } | undefined;
+        memoryExporter?: {
+            enabled?: boolean | undefined;
+            retentionTimeSeconds?: number | undefined;
+        } | undefined;
+        filters?: any[] | undefined;
+    } | undefined;
+    metrics?: {
+        mainMetricReaderOptions?: {
+            exportIntervalMillis?: number | undefined;
+            metricProducers?: ({
+                collect?: {} | undefined;
+            } | undefined)[] | undefined;
+        } | undefined;
+        extraReaders?: ({
+            setMetricProducer?: {} | undefined;
+            selectAggregation?: {} | undefined;
+            selectAggregationTemporality?: {} | undefined;
+            selectCardinalityLimit?: {} | undefined;
+            collect?: {} | undefined;
+            shutdown?: {} | undefined;
+            forceFlush?: {} | undefined;
+        } | undefined)[] | undefined;
+        extraViews?: ({
+            name?: string | undefined;
+            description?: string | undefined;
+            attributesProcessors?: ({
+                process?: {} | undefined;
+            } | undefined)[] | undefined;
+            aggregation?: {
+                type?: import("@opentelemetry/sdk-metrics").AggregationType.EXPONENTIAL_HISTOGRAM | undefined;
+                options?: {
+                    recordMinMax?: boolean | undefined;
+                    maxSize?: number | undefined;
+                } | undefined;
+            } | {
+                type?: import("@opentelemetry/sdk-metrics").AggregationType.EXPLICIT_BUCKET_HISTOGRAM | undefined;
+                options?: {
+                    recordMinMax?: boolean | undefined;
+                    boundaries?: (number | undefined)[] | undefined;
+                } | undefined;
+            } | {
+                type?: import("@opentelemetry/sdk-metrics").AggregationType.SUM | undefined;
+            } | {
+                type?: import("@opentelemetry/sdk-metrics").AggregationType.DROP | undefined;
+            } | {
+                type?: import("@opentelemetry/sdk-metrics").AggregationType.DEFAULT | undefined;
+            } | {
+                type?: import("@opentelemetry/sdk-metrics").AggregationType.LAST_VALUE | undefined;
+            } | undefined;
+            aggregationCardinalityLimit?: number | undefined;
+            instrumentType?: import("@opentelemetry/sdk-metrics").InstrumentType | undefined;
+            instrumentName?: string | undefined;
+            instrumentUnit?: string | undefined;
+            meterName?: string | undefined;
+            meterVersion?: string | undefined;
+            meterSchemaUrl?: string | undefined;
+        } | undefined)[] | undefined;
+        memoryExporter?: {
+            enabled?: boolean | undefined;
+            retentionTimeSeconds?: number | undefined;
+        } | undefined;
+        filters?: any[] | undefined;
+    } | undefined;
+    logs?: {
+        extraExporters?: ({
+            export?: {} | undefined;
+            shutdown?: {} | undefined;
+        } | undefined)[] | undefined;
+        extraProcessors?: ({
+            forceFlush?: {} | undefined;
+            onEmit?: {} | undefined;
+            shutdown?: {} | undefined;
+        } | undefined)[] | undefined;
+        memoryExporter?: {
+            enabled?: boolean | undefined;
+            retentionTimeSeconds?: number | undefined;
+        } | undefined;
+        filters?: any[] | undefined;
+    } | undefined;
+    plugins?: {
+        enabled?: boolean | undefined;
+        extraPlugins?: ({
+            [x: string]: any;
+            id?: string | undefined;
+            name?: string | undefined;
+            active?: boolean | undefined;
+            description?: string | undefined;
+            version?: string | undefined;
+            pluginImplementation?: {
+                newTrace?: {} | undefined;
+                newMetric?: {} | undefined;
+                newLog?: {} | undefined;
+            } | undefined;
+        } | undefined)[] | undefined;
+    } | undefined;
+};

package/dist/types/config/config.types.d.ts

@@ -0,0 +1,34 @@
+import { LogRecordExporter, LogRecordProcessor } from "@opentelemetry/sdk-logs";
+import { IMetricReader } from "@opentelemetry/sdk-metrics";
+import { SpanExporter, SpanProcessor } from "@opentelemetry/sdk-trace-node";
+import { defaultConfig } from "./config.js";
+import { ViewOptions } from "@opentelemetry/sdk-metrics/build/src/view/View.js";
+export type DeepPartial<T> = T extends object ? {
+    [P in keyof T]?: DeepPartial<T[P]>;
+} : T;
+export type OasTlmConfig = typeof defaultConfig;
+export type UserConfig = {
+    general?: Partial<OasTlmConfig["general"]>;
+    auth?: Partial<OasTlmConfig["auth"]>;
+    ai?: {
+        extraContextPrompts?: string[];
+        openAIModel?: string;
+    };
+    traces?: {
+        extraExporters?: SpanExporter[];
+        extraProcessors?: SpanProcessor[];
+        memoryExporter?: Partial<OasTlmConfig["traces"]["memoryExporter"]>;
+    };
+    metrics?: {
+        mainMetricReaderOptions?: Partial<OasTlmConfig["metrics"]["mainMetricReaderOptions"]>;
+        extraReaders?: IMetricReader[];
+        extraViews?: ViewOptions[];
+        memoryExporter?: Partial<OasTlmConfig["metrics"]["memoryExporter"]>;
+    };
+    logs?: {
+        extraExporters?: LogRecordExporter[];
+        extraProcessors?: LogRecordProcessor[];
+        memoryExporter?: Partial<OasTlmConfig["logs"]["memoryExporter"]>;
+    };
+    plugins?: Partial<OasTlmConfig["plugins"]>;
+};

package/dist/types/index.d.ts

@@ -1,8 +1,9 @@
-import './instrumentation/index.js';
+import "./config/bootConfig.js";
+import './telemetry/initializeTelemetry.js';
 import { Router } from 'express';
-import { OasTlmInputConfig } from './types/index.js';
+import { UserConfig } from './config/config.types.js';
 /**
- * Returns the Oas Telemetry middleware. The parameters are the same as `globalOasTlmConfig`.
+ * Returns the OAS-Telemetry middleware.
  * All parameters are optional. However, either `spec` or `specFileName` must be provided to enable endpoint filtering.
  */
-export default function oasTelemetry(oasTlmInputConfig: OasTlmInputConfig): Router;
+export default function oasTelemetry(oasTlmInputConfig?: UserConfig): Router;

package/dist/types/routesManager.d.ts

@@ -0,0 +1,3 @@
+import { Router } from "express";
+import { OasTlmConfig } from "./config/config.types.js";
+export declare const configureRoutes: (router: Router, oasTlmConfig: OasTlmConfig) => void;

package/dist/types/{exporters/InMemoryLogRecordExporter.d.ts → telemetry/custom-implementations/exporters/InMemoryDbLogExporter.d.ts}

@@ -1,10 +1,11 @@
 import { ExportResult } from '@opentelemetry/core';
 import { ReadableLogRecord, LogRecordExporter } from '@opentelemetry/sdk-logs';
-export declare class InMemoryLogRecordExporter implements LogRecordExporter {
+import { Enabler } from '../wrappers.js';
+export declare class InMemoryDbLogExporter extends Enabler implements LogRecordExporter {
     private _db;
     private _miniSearch;
-    private _stopped;
-    constructor();
+    private _retentionTimeInSeconds;
+    constructor(retentionTimeInSeconds?: number);
     /**
      * Export logs.
      * @param logs
@@ -18,9 +19,6 @@ export declare class InMemoryLogRecordExporter implements LogRecordExporter {
     shutdown(): Promise<void>;
     find(query: any, messageSearch: string | null, callback: (err: any, docs: any) => void): void;
     insert(data: any[], callback: (err: any, newDocs: any[]) => void): void;
-    start(): void;
-    stop(): void;
-    isRunning(): boolean;
     getFinishedLogs(): any[];
     /**
      *  @copyright The OpenTelemetry Authors
@@ -29,5 +27,7 @@ export declare class InMemoryLogRecordExporter implements LogRecordExporter {
      * @param logRecord
      */
     private _formatLogRecord;
+    set retentionTimeInSeconds(retentionTimeInSeconds: number);
     private _insertLogs;
+    private _startCleanupJob;
 }

package/dist/types/{exporters/InMemoryDBMetricsExporter.d.ts → telemetry/custom-implementations/exporters/InMemoryDbMetricExporter.d.ts}

@@ -1,12 +1,10 @@
-import { ResourceMetrics } from '@opentelemetry/sdk-metrics';
-export declare class InMemoryDBMetricsExporter {
+import { PushMetricExporter, ResourceMetrics } from '@opentelemetry/sdk-metrics';
+import { Enabler } from '../wrappers.js';
+export declare class InMemoryDbMetricExporter extends Enabler implements PushMetricExporter {
     private _metrics;
-    private _stopped;
-    constructor();
+    private _retentionTimeInSeconds;
+    constructor(retentionTimeInSeconds?: number);
     export(metrics: ResourceMetrics, resultCallback: any): any;
-    start(): void;
-    stop(): void;
-    isRunning(): boolean;
     shutdown(): Promise<void>;
     forceFlush(): Promise<void>;
     find(search: any, callback: any): void;
@@ -18,4 +16,6 @@ export declare class InMemoryDBMetricsExporter {
      * @param callback - The callback to execute after insertion.
      */
     insert(metrics: any[], callback: (err: any, newDocs: any[]) => void): void;
+    set retentionTimeInSeconds(retentionTimeInSeconds: number);
+    private _startCleanupJob;
 }

package/dist/types/{exporters/InMemoryDbExporter.d.ts → telemetry/custom-implementations/exporters/InMemoryDbSpanExporter.d.ts}

@@ -1,18 +1,17 @@
 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 {
+import { ReadableSpan, SpanExporter } from '@opentelemetry/sdk-trace-base';
+import { Enabler } from '../wrappers.js';
+export declare class InMemoryDbSpanExporter extends Enabler implements SpanExporter {
     private _spans;
-    private _stopped;
-    constructor();
-    plugins: PluginResource[];
+    private _baseUrl;
+    private _retentionTimeInSeconds;
+    constructor(retentionTimeInSeconds?: number);
+    set baseUrl(baseUrl: string);
+    set retentionTimeInSeconds(retentionTimeInSeconds: number);
     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
@@ -27,4 +26,5 @@ export declare class InMemoryExporter implements OasTlmExporter {
      * @param callback - The callback to execute after insertion.
      */
     insert(spans: any[], callback: (err: any, newDocs: any[]) => void): void;
+    _startCleanupJob(): void;
 }

package/dist/types/telemetry/custom-implementations/exporters/PluginLogExporter.d.ts

@@ -0,0 +1,8 @@
+import { ExportResult } from '@opentelemetry/core';
+import { ReadableLogRecord, LogRecordExporter } from '@opentelemetry/sdk-logs';
+import { Enabler } from '../wrappers.js';
+export declare class PluginLogExporter extends Enabler implements LogRecordExporter {
+    constructor();
+    export(logs: ReadableLogRecord[], resultCallback: (result: ExportResult) => void): void;
+    shutdown(): Promise<void>;
+}

package/dist/types/telemetry/custom-implementations/exporters/PluginMetricExporter.d.ts

@@ -0,0 +1,12 @@
+import { ExportResultCode } from '@opentelemetry/core';
+import { ResourceMetrics, PushMetricExporter } from '@opentelemetry/sdk-metrics';
+import { Enabler } from '../wrappers.js';
+export declare class PluginMetricExporter extends Enabler implements PushMetricExporter {
+    constructor();
+    export(metrics: ResourceMetrics, resultCallback: (result: {
+        code: ExportResultCode;
+        error?: Error;
+    }) => void): void;
+    shutdown(): Promise<void>;
+    forceFlush(): Promise<void>;
+}

package/dist/types/telemetry/custom-implementations/exporters/PluginSpanExporter.d.ts

@@ -0,0 +1,14 @@
+import { ExportResultCode } from '@opentelemetry/core';
+import { ReadableSpan, SpanExporter } from '@opentelemetry/sdk-trace-base';
+import { Enabler } from '../wrappers.js';
+export declare class PluginSpanExporter extends Enabler implements SpanExporter {
+    private _baseUrl;
+    constructor();
+    set baseUrl(baseUrl: string);
+    export(readableSpans: ReadableSpan[], resultCallback: (result: {
+        code: ExportResultCode;
+        error?: Error;
+    }) => void): void;
+    shutdown(): Promise<void>;
+    forceFlush(): Promise<void>;
+}

package/dist/types/telemetry/custom-implementations/processors/dynamicMultiLogProcessor.d.ts

@@ -0,0 +1,32 @@
+import type { Context } from '@opentelemetry/api';
+import type { LogRecordProcessor } from '@opentelemetry/sdk-logs';
+import type { LogRecord } from '@opentelemetry/sdk-logs';
+export declare class DynamicMultiLogRecordProcessor implements LogRecordProcessor {
+    private _processors;
+    private _forceFlushTimeoutMillis;
+    constructor(initialProcessors?: LogRecordProcessor[], forceFlushTimeoutMillis?: number);
+    /**
+     * Add a new LogRecordProcessor or an array of LogRecordProcessors at runtime.
+     */
+    addProcessors(processor: LogRecordProcessor | LogRecordProcessor[]): void;
+    /**
+     * Remove a specific LogRecordProcessor.
+     */
+    removeProcessor(processor: LogRecordProcessor): void;
+    /**
+     * Clear all LogRecordProcessors.
+     */
+    clearProcessors(): void;
+    /**
+     * Called when a log record is emitted.
+     */
+    onEmit(logRecord: LogRecord, context?: Context): void;
+    /**
+     * Force flush all processors with timeout.
+     */
+    forceFlush(): Promise<void>;
+    /**
+     * Shutdown all processors.
+     */
+    shutdown(): Promise<void>;
+}

package/dist/types/telemetry/custom-implementations/processors/dynamicMultiSpanProcessor.d.ts

@@ -0,0 +1,34 @@
+import { SpanProcessor, ReadableSpan, Span } from '@opentelemetry/sdk-trace-base';
+import { Context } from '@opentelemetry/api';
+export declare class DynamicMultiSpanProcessor implements SpanProcessor {
+    private _spanProcessors;
+    constructor(initialProcessors?: SpanProcessor[]);
+    /**
+     * Add a new SpanProcessor or an array of SpanProcessors at runtime.
+     */
+    addProcessors(processor: SpanProcessor | SpanProcessor[]): void;
+    /**
+     * Remove a specific SpanProcessor if needed.
+     */
+    removeProcessor(processor: SpanProcessor): void;
+    /**
+     * Clear all processors.
+     */
+    clearProcessors(): void;
+    /**
+     * Called when a span is started.
+     */
+    onStart(span: Span, context: Context): void;
+    /**
+     * Called when a span ends.
+     */
+    onEnd(span: ReadableSpan): void;
+    /**
+     * Force flush all processors.
+     */
+    forceFlush(): Promise<void>;
+    /**
+     * Shutdown all processors.
+     */
+    shutdown(): Promise<void>;
+}

package/dist/types/telemetry/custom-implementations/utils/circular.d.ts

@@ -0,0 +1,27 @@
+export declare function removeCircularRefs(obj: any): any;
+/**
+ * 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 declare function applyNesting(obj: any): any;