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

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

@@ -1,16 +1,19 @@
-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;
     };
+    storage: {
+        path: string | null;
+        loadFromStart: boolean;
+    };
     auth: {
         enabled: boolean;
         password: string;
@@ -61,14 +64,18 @@ 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;
     };
+    storage: {
+        path: string | null;
+        loadFromStart: boolean;
+    };
     auth: {
         enabled: boolean;
         password: string;
@@ -119,13 +126,17 @@ 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;
     } | undefined;
+    storage?: {
+        path?: string | null | undefined;
+        loadFromStart?: boolean | undefined;
+    } | undefined;
     auth?: {
         enabled?: boolean | undefined;
         password?: string | undefined;
@@ -147,6 +158,7 @@ export declare const getConfig: (userConfig?: UserConfig, fallbackConfig?: OasTl
         extraProcessors?: ({
             forceFlush?: {} | undefined;
             onStart?: {} | undefined;
+            onEnding?: {} | undefined;
             onEnd?: {} | undefined;
             shutdown?: {} | undefined;
         } | undefined)[] | undefined;
@@ -269,6 +281,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 +302,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 +331,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 +396,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 +446,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 +480,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 +501,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 +529,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 +593,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 +656,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 +677,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 +705,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 +768,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 +789,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 +817,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 +898,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,12 +3,14 @@ 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;
 export type OasTlmConfig = typeof defaultConfig;
 export type UserConfig = {
     general?: Partial<OasTlmConfig["general"]>;
+    storage?: Partial<OasTlmConfig["storage"]>;
     auth?: Partial<OasTlmConfig["auth"]>;
     ai?: {
         extraContextPrompts?: string[];
@@ -31,4 +33,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/DiskLogExporter.d.ts

@@ -0,0 +1,24 @@
+import { ExportResult } from '@opentelemetry/core';
+import { LogRecordExporter, ReadableLogRecord } from '@opentelemetry/sdk-logs';
+import { Enabler } from '../wrappers.js';
+export type DiskLogExporterOptions = {
+    directoryPath: string;
+    flushIntervalMs?: number;
+    batchSize?: number;
+    maxSegmentBytes?: number;
+};
+export declare class DiskLogExporter extends Enabler implements LogRecordExporter {
+    private readonly writer;
+    private readonly flushIntervalMs;
+    private readonly batchSize;
+    private queuedLogs;
+    private flushTimer;
+    private flushing;
+    constructor(options: DiskLogExporterOptions);
+    export(logs: ReadableLogRecord[], resultCallback: (result: ExportResult) => void): void;
+    shutdown(): Promise<void>;
+    forceFlush(): Promise<void>;
+    private scheduleFlush;
+    private flushPending;
+    private formatLogRecord;
+}

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

@@ -0,0 +1,23 @@
+import { ExportResult } from '@opentelemetry/core';
+import { PushMetricExporter, ResourceMetrics } from '@opentelemetry/sdk-metrics';
+import { Enabler } from '../wrappers.js';
+export type DiskMetricExporterOptions = {
+    directoryPath: string;
+    flushIntervalMs?: number;
+    batchSize?: number;
+    maxSegmentBytes?: number;
+};
+export declare class DiskMetricExporter extends Enabler implements PushMetricExporter {
+    private readonly writer;
+    private readonly flushIntervalMs;
+    private readonly batchSize;
+    private queuedScopeMetrics;
+    private flushTimer;
+    private flushing;
+    constructor(options: DiskMetricExporterOptions);
+    export(resourceMetrics: ResourceMetrics, resultCallback: (result: ExportResult) => void): void;
+    shutdown(): Promise<void>;
+    forceFlush(): Promise<void>;
+    private scheduleFlush;
+    private flushPending;
+}

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

@@ -0,0 +1,23 @@
+import { ExportResult } from '@opentelemetry/core';
+import { ReadableSpan, SpanExporter } from '@opentelemetry/sdk-trace-base';
+import { Enabler } from '../wrappers.js';
+export type DiskTraceExporterOptions = {
+    directoryPath: string;
+    flushIntervalMs?: number;
+    batchSize?: number;
+    maxSegmentBytes?: number;
+};
+export declare class DiskTraceExporter extends Enabler implements SpanExporter {
+    private readonly writer;
+    private readonly flushIntervalMs;
+    private readonly batchSize;
+    private queuedSpans;
+    private flushTimer;
+    private flushing;
+    constructor(options: DiskTraceExporterOptions);
+    export(spans: ReadableSpan[], resultCallback: (result: ExportResult) => void): void;
+    shutdown(): Promise<void>;
+    forceFlush(): Promise<void>;
+    private scheduleFlush;
+    private flushPending;
+}

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

@@ -5,7 +5,9 @@ export declare class InMemoryDbLogExporter extends Enabler implements LogRecordE
     private _db;
     private _miniSearch;
     private _retentionTimeInSeconds;
+    private _initialized;
     constructor(retentionTimeInSeconds?: number);
+    private _ensureInitialized;
     /**
      * Export logs.
      * @param logs
@@ -20,7 +22,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,63 @@
-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 _initialized;
+    private _ensureInitialized;
+    get rawDataDB(): any[];
+    constructor(config?: Partial<ExporterConfig>);
+    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 as line-delimited JSON (one chunk per line)
+     */
+    exportToLineDelimitedJson(): string;
+    /**
+     * Import metrics from line-delimited JSON format
+     */
+    importFromLineDelimitedJson(lineDelimitedJsonData: 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,10 @@ 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 _initialized;
     constructor(retentionTimeInSeconds?: number);
-    set baseUrl(baseUrl: string);
+    private _ensureInitialized;
     set retentionTimeInSeconds(retentionTimeInSeconds: number);
     get retentionTimeInSeconds(): number;
     export(readableSpans: ReadableSpan[], resultCallback: (arg0: {
@@ -14,12 +14,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/exporters/MultiMetricExporter.d.ts

@@ -0,0 +1,9 @@
+import { ExportResult } from '@opentelemetry/core';
+import { PushMetricExporter, ResourceMetrics } from '@opentelemetry/sdk-metrics';
+export declare class MultiMetricExporter implements PushMetricExporter {
+    private readonly exporters;
+    constructor(exporters: PushMetricExporter[]);
+    export(resourceMetrics: ResourceMetrics, resultCallback: (result: ExportResult) => void): void;
+    shutdown(): Promise<void>;
+    forceFlush(): Promise<void>;
+}

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 line-delimited JSON 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":[...]}
+     */
+    serializeToLineDelimitedJson(): string;
+    /**
+     * Deserialize from line-delimited JSON format - restore from chunk lines
+     */
+    deserializeFromLineDelimitedJson(lineDelimitedJsonData: string): void;
+    /**
+     * Save registry to disk as line-delimited JSON (one chunk per line)
+     */
+    saveToDisk(filePath: string): void;
+    /**
+     * Load registry from disk (line-delimited JSON format)
+     */
+    loadFromDisk(filePath: string): void;
+}
+export type MetricInfo = {
+    scope: InstrumentationScope;
+    metrics: Array<{
+        descriptor: MetricDescriptor;
+        series: string[];
+    }>;
+};