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

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

@@ -1,12 +1,11 @@
-import { OasTlmConfig, DeepPartial, UserConfig } from './config.types';
+import { OasTlmConfig, DeepPartial, UserConfig } from './config.types.js';
 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';
+import { type ViewOptions } from '@opentelemetry/sdk-metrics/build/src/view/View.js';
 export declare const defaultConfig: {
     general: {
-        baseUrl: string;
         specFileName: string | null;
         spec: string | null;
         uiPath: string;
@@ -61,10 +60,10 @@ export declare const defaultConfig: {
         enabled: boolean;
         extraPlugins: PluginResource[];
     };
+    instrumentations: any[];
 };
 export declare const getConfig: (userConfig?: UserConfig, fallbackConfig?: OasTlmConfig, envConfig?: DeepPartial<OasTlmConfig>) => {
     general: {
-        baseUrl: string;
         specFileName: string | null;
         spec: string | null;
         uiPath: string;
@@ -119,9 +118,9 @@ export declare const getConfig: (userConfig?: UserConfig, fallbackConfig?: OasTl
         enabled: boolean;
         extraPlugins: PluginResource[];
     };
+    instrumentations: any[];
 } & UserConfig & {
     general?: {
-        baseUrl?: string | undefined;
         specFileName?: string | null | undefined;
         spec?: string | null | undefined;
         uiPath?: string | undefined;
@@ -147,6 +146,7 @@ export declare const getConfig: (userConfig?: UserConfig, fallbackConfig?: OasTl
         extraProcessors?: ({
             forceFlush?: {} | undefined;
             onStart?: {} | undefined;
+            onEnding?: {} | undefined;
             onEnd?: {} | undefined;
             shutdown?: {} | undefined;
         } | undefined)[] | undefined;
@@ -269,6 +269,7 @@ export declare const getConfig: (userConfig?: UserConfig, fallbackConfig?: OasTl
                         name?: string | undefined;
                         message?: string | undefined;
                         stack?: string | undefined;
+                        cause?: unknown;
                     } | null | undefined;
                     readonly writableNeedDrain?: boolean | undefined;
                     _write?: {} | undefined;
@@ -289,6 +290,7 @@ export declare const getConfig: (userConfig?: UserConfig, fallbackConfig?: OasTl
                     prependListener?: {} | undefined;
                     prependOnceListener?: {} | undefined;
                     removeListener?: {} | undefined;
+                    [Symbol.asyncDispose]?: {} | undefined;
                     pipe?: {} | undefined;
                     compose?: {} | undefined;
                     [EventEmitter.captureRejectionSymbol]?: {} | undefined;
@@ -317,6 +319,7 @@ export declare const getConfig: (userConfig?: UserConfig, fallbackConfig?: OasTl
                         name?: string | undefined;
                         message?: string | undefined;
                         stack?: string | undefined;
+                        cause?: unknown;
                     } | null | undefined;
                     _construct?: {} | undefined;
                     _read?: {} | undefined;
@@ -381,6 +384,7 @@ export declare const getConfig: (userConfig?: UserConfig, fallbackConfig?: OasTl
                         name?: string | undefined;
                         message?: string | undefined;
                         stack?: string | undefined;
+                        cause?: unknown;
                     } | null | undefined;
                     _construct?: {} | undefined;
                     _read?: {} | undefined;
@@ -430,10 +434,24 @@ export declare const getConfig: (userConfig?: UserConfig, fallbackConfig?: OasTl
                     eventNames?: {} | undefined;
                 } | null | undefined;
                 readonly channel?: {
-                    close?: {} | undefined;
-                    hasRef?: {} | undefined;
                     ref?: {} | undefined;
                     unref?: {} | undefined;
+                    [EventEmitter.captureRejectionSymbol]?: {} | undefined;
+                    addListener?: {} | undefined;
+                    on?: {} | undefined;
+                    once?: {} | undefined;
+                    removeListener?: {} | undefined;
+                    off?: {} | undefined;
+                    removeAllListeners?: {} | undefined;
+                    setMaxListeners?: {} | undefined;
+                    getMaxListeners?: {} | undefined;
+                    listeners?: {} | undefined;
+                    rawListeners?: {} | undefined;
+                    emit?: {} | undefined;
+                    listenerCount?: {} | undefined;
+                    prependListener?: {} | undefined;
+                    prependOnceListener?: {} | undefined;
+                    eventNames?: {} | undefined;
                 } | null | undefined;
                 readonly stdio?: [({
                     readonly writable?: boolean | undefined;
@@ -450,6 +468,7 @@ export declare const getConfig: (userConfig?: UserConfig, fallbackConfig?: OasTl
                         name?: string | undefined;
                         message?: string | undefined;
                         stack?: string | undefined;
+                        cause?: unknown;
                     } | null | undefined;
                     readonly writableNeedDrain?: boolean | undefined;
                     _write?: {} | undefined;
@@ -470,6 +489,7 @@ export declare const getConfig: (userConfig?: UserConfig, fallbackConfig?: OasTl
                     prependListener?: {} | undefined;
                     prependOnceListener?: {} | undefined;
                     removeListener?: {} | undefined;
+                    [Symbol.asyncDispose]?: {} | undefined;
                     pipe?: {} | undefined;
                     compose?: {} | undefined;
                     [EventEmitter.captureRejectionSymbol]?: {} | undefined;
@@ -497,6 +517,7 @@ export declare const getConfig: (userConfig?: UserConfig, fallbackConfig?: OasTl
                         name?: string | undefined;
                         message?: string | undefined;
                         stack?: string | undefined;
+                        cause?: unknown;
                     } | null | undefined;
                     _construct?: {} | undefined;
                     _read?: {} | undefined;
@@ -560,6 +581,7 @@ export declare const getConfig: (userConfig?: UserConfig, fallbackConfig?: OasTl
                         name?: string | undefined;
                         message?: string | undefined;
                         stack?: string | undefined;
+                        cause?: unknown;
                     } | null | undefined;
                     _construct?: {} | undefined;
                     _read?: {} | undefined;
@@ -622,6 +644,7 @@ export declare const getConfig: (userConfig?: UserConfig, fallbackConfig?: OasTl
                         name?: string | undefined;
                         message?: string | undefined;
                         stack?: string | undefined;
+                        cause?: unknown;
                     } | null | undefined;
                     readonly writableNeedDrain?: boolean | undefined;
                     _write?: {} | undefined;
@@ -642,6 +665,7 @@ export declare const getConfig: (userConfig?: UserConfig, fallbackConfig?: OasTl
                     prependListener?: {} | undefined;
                     prependOnceListener?: {} | undefined;
                     removeListener?: {} | undefined;
+                    [Symbol.asyncDispose]?: {} | undefined;
                     pipe?: {} | undefined;
                     compose?: {} | undefined;
                     [EventEmitter.captureRejectionSymbol]?: {} | undefined;
@@ -669,6 +693,7 @@ export declare const getConfig: (userConfig?: UserConfig, fallbackConfig?: OasTl
                         name?: string | undefined;
                         message?: string | undefined;
                         stack?: string | undefined;
+                        cause?: unknown;
                     } | null | undefined;
                     _construct?: {} | undefined;
                     _read?: {} | undefined;
@@ -731,6 +756,7 @@ export declare const getConfig: (userConfig?: UserConfig, fallbackConfig?: OasTl
                         name?: string | undefined;
                         message?: string | undefined;
                         stack?: string | undefined;
+                        cause?: unknown;
                     } | null | undefined;
                     readonly writableNeedDrain?: boolean | undefined;
                     _write?: {} | undefined;
@@ -751,6 +777,7 @@ export declare const getConfig: (userConfig?: UserConfig, fallbackConfig?: OasTl
                     prependListener?: {} | undefined;
                     prependOnceListener?: {} | undefined;
                     removeListener?: {} | undefined;
+                    [Symbol.asyncDispose]?: {} | undefined;
                     pipe?: {} | undefined;
                     compose?: {} | undefined;
                     [EventEmitter.captureRejectionSymbol]?: {} | undefined;
@@ -778,6 +805,7 @@ export declare const getConfig: (userConfig?: UserConfig, fallbackConfig?: OasTl
                         name?: string | undefined;
                         message?: string | undefined;
                         stack?: string | undefined;
+                        cause?: unknown;
                     } | null | undefined;
                     _construct?: {} | undefined;
                     _read?: {} | undefined;
@@ -858,4 +886,5 @@ export declare const getConfig: (userConfig?: UserConfig, fallbackConfig?: OasTl
             } | undefined;
         } | undefined)[] | undefined;
     } | undefined;
+    instrumentations?: any[] | undefined;
 };

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

@@ -3,6 +3,7 @@ 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";
+import { type Instrumentation } from "@opentelemetry/instrumentation";
 export type DeepPartial<T> = T extends object ? {
     [P in keyof T]?: DeepPartial<T[P]>;
 } : T;
@@ -31,4 +32,9 @@ export type UserConfig = {
         memoryExporter?: Partial<OasTlmConfig["logs"]["memoryExporter"]>;
     };
     plugins?: Partial<OasTlmConfig["plugins"]>;
+    /**
+     * User can register its own instrumentations to be used by oas-telemetry. oas-telemetry will assign the providers to these instrumentations.
+     * This is useful when the user wants to use instrumentations that are not included by default in oas-telemetry.
+     */
+    instrumentations?: Instrumentation[];
 };

package/dist/types/index.d.ts

@@ -1,10 +1,9 @@
 import "./config/bootConfig.js";
 import './telemetry/initializeTelemetry.js';
-import { Router } from 'express';
 import { UserConfig } from './config/config.types.js';
 /**
  * Returns the OAS-Telemetry middleware.
  * All parameters are optional. However, either `spec` or `specFileName` must be provided to enable endpoint filtering.
  */
-declare function oasTelemetry(oasTlmInputConfig?: UserConfig): Router;
-export = oasTelemetry;
+declare function oasTelemetry(oasTlmInputConfig?: UserConfig): any;
+export { oasTelemetry };

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

@@ -5,7 +5,10 @@ export declare class InMemoryDbLogExporter extends Enabler implements LogRecordE
     private _db;
     private _miniSearch;
     private _retentionTimeInSeconds;
+    private _storagePath;
+    private _initialized;
     constructor(retentionTimeInSeconds?: number);
+    private _ensureInitialized;
     /**
      * Export logs.
      * @param logs
@@ -20,7 +23,7 @@ export declare class InMemoryDbLogExporter extends Enabler implements LogRecordE
     find(findConfig: {
         query: any;
         messageSearch: string | null;
-        limit: number;
+        limit?: number;
         sortOrder?: any;
     }): Promise<any[]>;
     insert(data: any[], callback: (err: any, newDocs: any[]) => void): void;

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

@@ -1,22 +1,67 @@
-import { PushMetricExporter, ResourceMetrics } from '@opentelemetry/sdk-metrics';
+import { PushMetricExporter, ResourceMetrics, ScopeMetrics } from '@opentelemetry/sdk-metrics';
 import { Enabler } from '../wrappers.js';
+import { Resource } from '@opentelemetry/resources';
+import { FindMetricsRequest } from '../metrics/tsdb/types.js';
+export interface ExporterConfig {
+    retentionTimeInSeconds?: number;
+    chunkSize?: number;
+    maxChunks?: number;
+}
+/**
+ * In-Memory TSDB Metric Exporter
+ * Series identified by: scope + metricName + attributes
+ */
 export declare class InMemoryDbMetricExporter extends Enabler implements PushMetricExporter {
-    private _metrics;
-    private _retentionTimeInSeconds;
-    constructor(retentionTimeInSeconds?: number);
-    export(metrics: ResourceMetrics, resultCallback: any): any;
+    private static readonly DEFAULT_CONFIG;
+    private readonly registry;
+    private readonly config;
+    private cachedResource;
+    private _storageFilePath;
+    private _autoSaveInterval;
+    private _storageLogged;
+    get rawDataDB(): any[];
+    constructor(config?: Partial<ExporterConfig>);
+    private _loadMetricsFromDisk;
+    private _startAutoSave;
+    private _saveMetricsToDisk;
+    export(resourceMetrics: ResourceMetrics, resultCallback: any): any;
     shutdown(): Promise<void>;
-    forceFlush(): Promise<void>;
-    find(search: any, callback: any): void;
     reset(): void;
-    getFinishedMetrics(): import("@seald-io/nedb").Document<Record<string, any>>[];
-    /**
-     * Inserts metrics into the in-memory database.
-     * @param metrics - The metrics to insert.
-     * @param callback - The callback to execute after insertion.
-     */
-    insert(metrics: any[], callback: (err: any, newDocs: any[]) => void): void;
-    set retentionTimeInSeconds(retentionTimeInSeconds: number);
+    forceFlush(): Promise<void>;
+    getCachedResource(): Resource | null;
+    set retentionTimeInSeconds(value: number);
     get retentionTimeInSeconds(): number;
+    getStats(): {
+        totalMetrics: number;
+        totalScopes: number;
+        totalSeries: number;
+        totalSamples: number;
+        memoryUsageBytes: number;
+    };
     private _startCleanupJob;
+    /**
+     * Find metrics by scope+metric queries with filters
+     * Supports both raw and otel formats
+     */
+    find(request: FindMetricsRequest): {
+        results: any[];
+    };
+    /**
+     * Export all metrics to NDJSON format (one chunk per line)
+     */
+    exportToNDJSON(): string;
+    /**
+     * Import metrics from NDJSON format
+     */
+    importFromNDJSON(ndjsonData: string): void;
+    /**
+ * Insert metrics in OpenTelemetry (OTEL) format directly into the registry
+ * @param scopeMetrics Array of ScopeMetrics (OTEL format)
+ */
+    insertOtel(scopeMetrics: ScopeMetrics[]): void;
+    /**
+     * Insert metrics in raw format (MetricQueryResult[]), converts to OTEL and delegates to insertOtel
+     * @param rawScopeMetrics Array of MetricQueryResult (raw format)
+     */
+    insertRaw(rawScopeMetrics: any[]): void;
 }

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

@@ -3,10 +3,11 @@ import { ReadableSpan, SpanExporter } from '@opentelemetry/sdk-trace-base';
 import { Enabler } from '../wrappers.js';
 export declare class InMemoryDbSpanExporter extends Enabler implements SpanExporter {
     private _spans;
-    private _baseUrl;
     private _retentionTimeInSeconds;
+    private _storagePath;
+    private _initialized;
     constructor(retentionTimeInSeconds?: number);
-    set baseUrl(baseUrl: string);
+    private _ensureInitialized;
     set retentionTimeInSeconds(retentionTimeInSeconds: number);
     get retentionTimeInSeconds(): number;
     export(readableSpans: ReadableSpan[], resultCallback: (arg0: {
@@ -14,12 +15,16 @@ export declare class InMemoryDbSpanExporter extends Enabler implements SpanExpor
         error?: Error;
     }) => void): void;
     shutdown(): Promise<void>;
+    reset(): void;
     /**
      * Exports any pending spans in the exporter
      */
     forceFlush(): Promise<void>;
-    find(search: any, callback: any): void;
-    reset(): void;
+    find(findConfig: {
+        query: any;
+        limit?: number;
+        sortOrder?: any;
+    }): Promise<any[]>;
     getFinishedSpans(): import("@seald-io/nedb").Document<Record<string, any>>[];
     /**
      * Inserts spans into the in-memory database.

package/dist/types/telemetry/custom-implementations/instrumentations/logsInstrumentation.d.ts

@@ -0,0 +1,23 @@
+import { InstrumentationBase } from '@opentelemetry/instrumentation';
+import { LoggerProvider } from '@opentelemetry/api-logs';
+export declare class LogsInstrumentation extends InstrumentationBase {
+    private _loggerProvider?;
+    private _otelLogger?;
+    constructor(config?: any);
+    /**
+     * No-op: this instrumentation does not patch modules loaded via require().
+     */
+    init(): never[];
+    /**
+     * Called by the SDK when the LoggerProvider is available.
+     * This is the correct way for an instrumentation to receive a logger provider.
+     */
+    setLoggerProvider(provider: LoggerProvider): void;
+    /**
+     * Called by the SDK after all providers have been registered.
+     */
+    enable(): void;
+    disable(): void;
+    private _patchConsole;
+    private _unpatchConsole;
+}

package/dist/types/telemetry/custom-implementations/metrics/tsdb/Chunk.d.ts

@@ -0,0 +1,49 @@
+import { HistogramValue } from './types.js';
+export declare class Chunk {
+    private readonly maxSamples;
+    private readonly startTimes;
+    private readonly endTimes;
+    private readonly values;
+    private readonly histograms;
+    private cursor;
+    private minEndTime;
+    private maxEndTime;
+    private readonly isHistogram;
+    constructor(maxSamples?: number, isHistogram?: boolean);
+    /**
+     * Append a sample to the chunk.
+     * Returns true if successful or false if the chunk is full.
+     */
+    append(startTime: number, endTime: number, value: number | HistogramValue): boolean;
+    /**
+     * Binary search for first index with endTime >= targetTime
+     */
+    private _binarySearchStart;
+    /**
+     * Binary search for last index with endTime <= targetTime
+     */
+    private _binarySearchEnd;
+    /**
+     * Efficient slicing method for bulk operations.
+     * Always returns slices. Values can be either a Float64Array (numeric)
+     * or a JS array of HistogramValue objects (histogram series).
+     */
+    getSlices(startTime?: number, endTime?: number): {
+        startTimes: Float64Array;
+        endTimes: Float64Array;
+        values: Float64Array | (HistogramValue | null)[];
+    };
+    isFull(): boolean;
+    overlaps(startTime: number, endTime: number): boolean;
+    getStats(): {
+        samples: number;
+        maxSamples: number;
+        minEndTime: number;
+        maxEndTime: number;
+        memoryBytes: number;
+    };
+    getMemoryUsage(): number;
+    getMinTime(): number;
+    getMaxTime(): number;
+    size(): number;
+}

package/dist/types/telemetry/custom-implementations/metrics/tsdb/Series.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Series: Time-series storage with metadata and chunks
+ * One series per unique metric+labels combination
+ */
+import { MetricMetadata, LabelSet, HistogramValue } from './types.js';
+export declare class Series {
+    private readonly labelSet;
+    private readonly metadata;
+    private readonly chunks;
+    private readonly maxChunks;
+    private readonly chunkSize;
+    private readonly isHistogram;
+    constructor(labelSet: LabelSet, metadata: MetricMetadata, chunkSize?: number, maxChunks?: number);
+    /**
+     * Append a sample to the series
+     */
+    append(startTime: number, endTime: number, value: number | HistogramValue): void;
+    /**
+     * Query slices with options object. Example:
+     *   querySlices({ startTime, endTime, includeStartTimes: true })
+     *   includeStartTimes defaults to false.
+     *   If both startTime and endTime are undefined, returns all data (no time filtering).
+     */
+    querySlices(options?: {
+        startTime?: number;
+        endTime?: number;
+        includeStartTimes?: boolean;
+    }): {
+        startTimes?: Float64Array;
+        endTimes: Float64Array;
+        values: Float64Array | (HistogramValue | null)[];
+    };
+    /**
+     * Remove chunks older than threshold
+     */
+    evictOldChunks(thresholdTime: number): number;
+    /**
+     * Get series metadata
+     */
+    getMetadata(): MetricMetadata;
+    getLabels(): Record<string, any>;
+    getOriginalAttributes(): Record<string, any>;
+    /**
+     * Get label hash
+     */
+    getLabelHash(): number;
+    getStats(): {
+        metricName: string;
+        labels: import("@opentelemetry/api").Attributes;
+        chunks: number;
+        samples: number;
+        memoryBytes: number;
+        oldestTime: number;
+        newestTime: number;
+    };
+    /**
+     * Check if series has any samples
+     */
+    isEmpty(): boolean;
+    /**
+     * Get time range covered by this series
+     */
+    getTimeRange(): {
+        min: number;
+        max: number;
+    };
+}

package/dist/types/telemetry/custom-implementations/metrics/tsdb/SeriesRegistry.d.ts

@@ -0,0 +1,69 @@
+import { ScopeMetricQuery, MetricQueryResult } from './types.js';
+import { InstrumentationScope } from '@opentelemetry/core';
+import { MetricDescriptor, ScopeMetrics } from '@opentelemetry/sdk-metrics';
+export declare class SeriesRegistry {
+    private readonly series;
+    private readonly scopes;
+    private readonly metricMetadataMap;
+    private readonly metricIdIndex;
+    private readonly chunkSize;
+    private readonly maxChunks;
+    constructor(chunkSize?: number, maxChunks?: number);
+    /**
+     * Store entire ScopeMetrics array efficiently
+     * Replaces addSample - processes all metrics in one batch
+     */
+    storeScopeMetrics(scopeMetrics: ScopeMetrics[]): void;
+    query(scopeMetrics?: ScopeMetricQuery[], startTime?: number, endTime?: number): MetricQueryResult[];
+    /**
+     * Query single metric with attribute filters
+     */
+    private _querySingle;
+    /**
+     * Match series attributes against filters
+     * Supports exact match, negation (!), and regex (~)
+     */
+    private _matchesAttributeFilters;
+    evictOldData(retentionTimeNs: number): {
+        evictedChunks: number;
+        evictedSeries: number;
+    };
+    getStats(): {
+        totalMetrics: number;
+        totalScopes: number;
+        totalSeries: number;
+        totalSamples: number;
+        memoryUsageBytes: number;
+    };
+    reset(): void;
+    size(): number;
+    /**
+     * Serialize registry to NDJSON format (newline-delimited JSON)
+     * Each line is a complete record: metadata, scope, metric, or data point
+     * Format:
+     *   {"type":"header","version":1,"timestamp":"...","stats":{...}}
+     *   {"type":"scope","id":"...","data":{...}}
+     *   {"type":"metric","id":"...","data":{...}}
+     *   {"type":"series","id":"...","labelSet":{...},"chunks":[...]}
+     */
+    serializeToNDJSON(): string;
+    /**
+     * Deserialize from NDJSON format - restore from chunk lines
+     */
+    deserializeFromNDJSON(ndjsonData: string): void;
+    /**
+     * Save registry to disk as NDJSON (one chunk per line)
+     */
+    saveToDisk(filePath: string): void;
+    /**
+     * Load registry from disk (NDJSON format)
+     */
+    loadFromDisk(filePath: string): void;
+}
+export type MetricInfo = {
+    scope: InstrumentationScope;
+    metrics: Array<{
+        descriptor: MetricDescriptor;
+        series: string[];
+    }>;
+};

package/dist/types/telemetry/custom-implementations/metrics/tsdb/types.d.ts

@@ -0,0 +1,68 @@
+import { InstrumentationScope } from "@opentelemetry/core";
+import { MetricData, Histogram, MetricDescriptor } from "@opentelemetry/sdk-metrics";
+import { Attributes } from "@opentelemetry/api";
+export type MetricMetadata = Omit<MetricData, "dataPoints">;
+export type HistogramValue = Histogram;
+/**
+ * Label set for series identification
+ */
+export interface LabelSet {
+    hash: number;
+    labels: Attributes;
+    originalAttributes: Attributes;
+}
+/**
+ * Series identifier: scope + metricName + attributes
+ */
+export interface SeriesKey {
+    scopeId: string;
+    metricName: string;
+    attributesId: number;
+}
+/**
+ * Sample with startTime, endTime and value (matching OTEL format)
+ */
+export interface Sample {
+    startTime: number;
+    endTime: number;
+    value: number | Histogram;
+}
+/**
+ * Raw TSDB format
+ */
+export interface RawScopeMetric {
+    scope: InstrumentationScope;
+    metadata: MetricData;
+    series: Array<{
+        attributes: Attributes;
+        startTimes: number[];
+        endTimes: number[];
+        values: number[];
+    }>;
+}
+export interface ScopeMetricQuery {
+    scope: InstrumentationScope;
+    descriptor: {
+        name: string;
+    };
+    filters?: Record<string, string>;
+}
+export interface FindMetricsRequest {
+    scopeMetrics?: ScopeMetricQuery[];
+    from?: number;
+    to?: number;
+    format?: 'otel' | 'raw';
+}
+/**
+ * Query result for metrics
+ */
+export interface MetricQueryResult {
+    scope: InstrumentationScope;
+    descriptor: MetricDescriptor;
+    series: Array<{
+        attributes: Attributes;
+        startTimes?: number[];
+        endTimes: number[];
+        values: number[] | (Histogram | null)[];
+    }>;
+}

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

@@ -0,0 +1,21 @@
+import { ScopeMetrics } from '@opentelemetry/sdk-metrics';
+import { type MetricQueryResult } from './types.js';
+/**
+ * Convert raw format to OpenTelemetry format
+ *
+ * Raw format structure (same for GET response and INSERT input):
+ * {
+ *   scope: { name, version },
+ *   descriptor: { unit, description, ... },
+ *   series: [{ attributes, startTimes[], endTimes[], values[] }]
+ * }
+ *
+ * OTEL format structure:
+ * {
+ *   scope: { name, version },
+ *   metrics: [{ descriptor, dataPoints: [{ attributes, startTime, endTime, value }] }]
+ * }
+ *
+ * Groups dataPoints by endTime to reconstruct original exports
+ */
+export declare function rawToOtel(rawScopeMetrics: MetricQueryResult[]): ScopeMetrics[];

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

@@ -1,6 +1,6 @@
 import type { Context } from '@opentelemetry/api';
 import type { LogRecordProcessor } from '@opentelemetry/sdk-logs';
-import type { LogRecord } from '@opentelemetry/sdk-logs';
+import type { SdkLogRecord } from '@opentelemetry/sdk-logs';
 export declare class DynamicMultiLogRecordProcessor implements LogRecordProcessor {
     private _processors;
     private _forceFlushTimeoutMillis;
@@ -20,7 +20,7 @@ export declare class DynamicMultiLogRecordProcessor implements LogRecordProcesso
     /**
      * Called when a log record is emitted.
      */
-    onEmit(logRecord: LogRecord, context?: Context): void;
+    onEmit(logRecord: SdkLogRecord, context?: Context): void;
     /**
      * Force flush all processors with timeout.
      */