apm-optima 1.0.4 → 2.0.0

package/dist/config/config.manager.d.ts

@@ -1,12 +1,89 @@
-import { ConfigOptions, ReadonlyConfig } from './config.types';
+import type { ClientConfig, ConfigOptions, ReadonlyConfig } from './config.types';
+export declare const DEFAULT_CONFIG: {
+    readonly applicationVersion: "1.0.0";
+    readonly logging: {
+        readonly consoleLog: true;
+    };
+    readonly collection: {
+        readonly excludePaths: readonly string[];
+        readonly includeDefaultExcludes: true;
+        readonly bucketIntervalMs: 1000;
+        readonly maxEndpointsPerBucket: 200;
+        readonly eventLoopResolutionMs: 20;
+    };
+    readonly thresholds: {
+        readonly slowLatencyMs: 500;
+        readonly eventLoopLagMs: 100;
+    };
+    readonly cache: {
+        readonly liveBuckets: 300;
+        readonly viewWindowBuckets: 60;
+    };
+    readonly persistence: {
+        readonly baseDir: "./metrics_data";
+        readonly persistRawRequests: true;
+        readonly maxBufferSize: 1000;
+        readonly archiveIntervalMs: number;
+        readonly heartbeatIntervalMs: 30000;
+        readonly shutdownDrainTimeoutMs: 5000;
+        readonly writer: {
+            readonly maxQueue: 1000;
+            readonly maxRetries: 3;
+            readonly retryDelayMs: 100;
+        };
+    };
+    readonly incidents: {
+        readonly windowIntervals: 60;
+        readonly minRequests: 100;
+        readonly serverErrorRate: 0.05;
+        readonly recoveryRatio: 0.5;
+        readonly pendingForMs: 30000;
+        readonly recoveryForMs: 60000;
+        readonly resolvedHoldMs: 30000;
+        readonly historySize: 100;
+    };
+    readonly correlation: {
+        readonly minCorrelation: 0.5;
+        readonly alpha: 0.05;
+        readonly power: 0.8;
+        readonly strongThreshold: 0.7;
+        readonly maxLag: 10;
+        readonly maxWindow: 60;
+        readonly minCoverage: 0.5;
+        readonly evaluateEveryIntervals: 10;
+    };
+    readonly dashboard: {
+        readonly path: "/optima-metrics";
+        readonly liveWindow: 60;
+        readonly backfillLimit: 1000;
+        readonly maxBackfillAgeMs: number;
+        readonly topImpactRoutes: 10;
+        readonly analyticsPageSize: 50;
+        readonly sessionSummaryWindowHours: 24;
+    };
+    readonly transport: {
+        readonly socketPath: "/socket.io/";
+        readonly cors: string | boolean;
+        readonly pingTimeoutMs: 5000;
+        readonly maxHttpBufferSize: number;
+    };
+    readonly publisher: {
+        readonly intervalMs: 1000;
+    };
+    readonly tickIntervalMs: 250;
+    readonly simulation: {
+        readonly intervalMs: 100;
+        readonly requestsPerTick: 20;
+    };
+};
+export declare function toClientConfig(config: ReadonlyConfig): ClientConfig;
 export declare class ConfigManager {
     private static instance;
     private config;
-    private readonly defaultConfig;
+    private initialized;
     private constructor();
     static getInstance(): ConfigManager;
     initialize(userOptions?: ConfigOptions): ReadonlyConfig;
     get(): ReadonlyConfig;
-    private validateAndSanitize;
 }
 export declare const getConfig: () => ReadonlyConfig;

package/dist/config/config.manager.js

@@ -1,41 +1,269 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getConfig = exports.ConfigManager = void 0;
-class ConfigManager {
-    static instance;
-    config;
-    defaultConfig = Object.freeze({
-        dashboardPath: '/optima-metrics',
-        simulation: {
-            intervalMs: 100,
-            requestsPerTick: 20,
+exports.getConfig = exports.ConfigManager = exports.DEFAULT_CONFIG = void 0;
+exports.toClientConfig = toClientConfig;
+const logger_1 = __importDefault(require("../core/telemetry/logger"));
+const DEFAULT_EXCLUDE_PATHS = [
+    '/_next/**',
+    '**/*.map',
+    '**/*.js',
+    '**/*.css',
+    '/favicon.ico',
+];
+exports.DEFAULT_CONFIG = {
+    applicationVersion: '1.0.0',
+    logging: { consoleLog: true },
+    collection: {
+        excludePaths: [],
+        includeDefaultExcludes: true,
+        bucketIntervalMs: 1000,
+        maxEndpointsPerBucket: 200,
+        eventLoopResolutionMs: 20,
+    },
+    thresholds: {
+        slowLatencyMs: 500,
+        eventLoopLagMs: 100
+    },
+    cache: {
+        liveBuckets: 300,
+        viewWindowBuckets: 60
+    },
+    persistence: {
+        baseDir: './metrics_data',
+        persistRawRequests: true,
+        maxBufferSize: 1000,
+        archiveIntervalMs: 24 * 60 * 60 * 1000,
+        heartbeatIntervalMs: 30000,
+        shutdownDrainTimeoutMs: 5000,
+        writer: {
+            maxQueue: 1000,
+            maxRetries: 3,
+            retryDelayMs: 100
+        }
+    },
+    incidents: {
+        windowIntervals: 60,
+        minRequests: 100,
+        serverErrorRate: 0.05,
+        recoveryRatio: 0.5,
+        pendingForMs: 30000,
+        recoveryForMs: 60000,
+        resolvedHoldMs: 30000,
+        historySize: 100
+    },
+    correlation: {
+        minCorrelation: 0.5,
+        alpha: 0.05,
+        power: 0.8,
+        strongThreshold: 0.7,
+        maxLag: 10,
+        maxWindow: 60,
+        minCoverage: 0.5,
+        evaluateEveryIntervals: 10
+    },
+    dashboard: {
+        path: '/optima-metrics',
+        liveWindow: 60,
+        backfillLimit: 1000,
+        maxBackfillAgeMs: 24 * 60 * 60 * 1000,
+        topImpactRoutes: 10,
+        analyticsPageSize: 50,
+        sessionSummaryWindowHours: 24
+    },
+    transport: {
+        socketPath: '/socket.io/',
+        cors: '*',
+        pingTimeoutMs: 5000,
+        maxHttpBufferSize: 1 * 1024 * 1024
+    },
+    publisher: {
+        intervalMs: 1000
+    },
+    tickIntervalMs: 250,
+    simulation: {
+        intervalMs: 100,
+        requestsPerTick: 20
+    },
+};
+function num(value, fallback, min, max = Number.POSITIVE_INFINITY) {
+    if (typeof value !== 'number' || Number.isNaN(value)) {
+        return fallback;
+    }
+    return Math.min(Math.max(value, min), max);
+}
+function bool(value, fallback) {
+    if (typeof value !== 'boolean') {
+        return fallback;
+    }
+    return value;
+}
+function str(value, fallback) {
+    if (typeof value !== 'string' || value.length === 0) {
+        return fallback;
+    }
+    return value;
+}
+function enabled(value, enabledByDefault) {
+    if (value === undefined)
+        return enabledByDefault ? {} : false;
+    if (value === false)
+        return false;
+    if (value === true)
+        return {};
+    if (typeof value === 'object' && value !== null)
+        return value;
+    return enabledByDefault ? {} : false;
+}
+function normalizePath(path) {
+    const withSlash = path.startsWith('/') ? path : `/${path}`;
+    return withSlash.length > 1 ? withSlash.replace(/\/+$/, '') : withSlash;
+}
+function deepFreeze(value) {
+    if (value !== null && typeof value === 'object' && !Object.isFrozen(value)) {
+        Object.freeze(value);
+        for (const v of Object.values(value))
+            deepFreeze(v);
+    }
+    return value;
+}
+function resolve(o = {}) {
+    const d = exports.DEFAULT_CONFIG;
+    const dashboardOptions = enabled(o.dashboard, true);
+    const dashboard = dashboardOptions === false ? false : {
+        path: normalizePath(str(dashboardOptions.path, d.dashboard.path)),
+        liveWindow: num(dashboardOptions.liveWindow, d.dashboard.liveWindow, 1),
+        backfillLimit: num(dashboardOptions.backfillLimit, d.dashboard.backfillLimit, 1),
+        maxBackfillAgeMs: num(dashboardOptions.maxBackfillAgeMs, d.dashboard.maxBackfillAgeMs, 1),
+        topImpactRoutes: num(dashboardOptions.topImpactRoutes, d.dashboard.topImpactRoutes, 1),
+        analyticsPageSize: num(dashboardOptions.analyticsPageSize, d.dashboard.analyticsPageSize, 1),
+        sessionSummaryWindowHours: num(dashboardOptions.sessionSummaryWindowHours, d.dashboard.sessionSummaryWindowHours, 1),
+    };
+    const collection = o.collection ?? {};
+    const includeDefaultExcludes = bool(collection.includeDefaultExcludes, d.collection.includeDefaultExcludes);
+    const userExcludes = Array.isArray(collection.excludePaths)
+        ? collection.excludePaths.filter((p) => typeof p === 'string' && p.length > 0)
+        : [...d.collection.excludePaths];
+    const excludePaths = [...new Set([
+            ...(includeDefaultExcludes ? DEFAULT_EXCLUDE_PATHS : []),
+            ...(dashboard !== false ? [dashboard.path, `${dashboard.path}/**`] : []),
+            ...userExcludes,
+        ])];
+    const persistenceOptions = enabled(o.persistence, true);
+    const writer = persistenceOptions === false ? undefined : persistenceOptions.writer ?? {};
+    const persistence = persistenceOptions === false ? false : {
+        baseDir: str(persistenceOptions.baseDir, d.persistence.baseDir),
+        persistRawRequests: bool(persistenceOptions.persistRawRequests, d.persistence.persistRawRequests),
+        maxBufferSize: num(persistenceOptions.maxBufferSize, d.persistence.maxBufferSize, 1),
+        archiveIntervalMs: num(persistenceOptions.archiveIntervalMs, d.persistence.archiveIntervalMs, 1000),
+        heartbeatIntervalMs: num(persistenceOptions.heartbeatIntervalMs, d.persistence.heartbeatIntervalMs, 1000),
+        shutdownDrainTimeoutMs: num(persistenceOptions.shutdownDrainTimeoutMs, d.persistence.shutdownDrainTimeoutMs, 0),
+        writer: {
+            maxQueue: num(writer?.maxQueue, d.persistence.writer.maxQueue, 1),
+            maxRetries: num(writer?.maxRetries, d.persistence.writer.maxRetries, 0),
+            retryDelayMs: num(writer?.retryDelayMs, d.persistence.writer.retryDelayMs, 1),
+        },
+    };
+    const simulationOptions = enabled(o.simulation, false);
+    const simulation = simulationOptions === false ? false : {
+        intervalMs: num(simulationOptions.intervalMs, d.simulation.intervalMs, 1),
+        requestsPerTick: num(simulationOptions.requestsPerTick, d.simulation.requestsPerTick, 1),
+    };
+    const thresholds = o.thresholds ?? {};
+    const cache = o.cache ?? {};
+    const incidents = o.incidents ?? {};
+    const correlation = o.correlation ?? {};
+    const transport = o.transport ?? {};
+    const viewWindowBuckets = num(cache.viewWindowBuckets, d.cache.viewWindowBuckets, 1);
+    const correlationMaxWindow = num(correlation.maxWindow, d.correlation.maxWindow, 1);
+    const incidentWindow = num(incidents.windowIntervals, d.incidents.windowIntervals, 1);
+    return {
+        applicationVersion: str(o.applicationVersion, d.applicationVersion),
+        logging: {
+            consoleLog: bool(o.logging?.consoleLog, d.logging.consoleLog),
+        },
+        collection: {
+            excludePaths,
+            includeDefaultExcludes,
+            bucketIntervalMs: num(collection.bucketIntervalMs, d.collection.bucketIntervalMs, 100),
+            maxEndpointsPerBucket: num(collection.maxEndpointsPerBucket, d.collection.maxEndpointsPerBucket, 1),
+            eventLoopResolutionMs: num(collection.eventLoopResolutionMs, d.collection.eventLoopResolutionMs, 1),
+        },
+        thresholds: {
+            slowLatencyMs: num(thresholds.slowLatencyMs, d.thresholds.slowLatencyMs, 1),
+            eventLoopLagMs: num(thresholds.eventLoopLagMs, d.thresholds.eventLoopLagMs, 1),
+        },
+        cache: {
+            liveBuckets: Math.max(num(cache.liveBuckets, d.cache.liveBuckets, 1), viewWindowBuckets, correlationMaxWindow, incidentWindow),
+            viewWindowBuckets,
+        },
+        persistence,
+        incidents: {
+            windowIntervals: incidentWindow,
+            minRequests: num(incidents.minRequests, d.incidents.minRequests, 1),
+            serverErrorRate: num(incidents.serverErrorRate, d.incidents.serverErrorRate, 0, 1),
+            recoveryRatio: num(incidents.recoveryRatio, d.incidents.recoveryRatio, 0, 1),
+            pendingForMs: num(incidents.pendingForMs, d.incidents.pendingForMs, 0),
+            recoveryForMs: num(incidents.recoveryForMs, d.incidents.recoveryForMs, 0),
+            resolvedHoldMs: num(incidents.resolvedHoldMs, d.incidents.resolvedHoldMs, 0),
+            historySize: num(incidents.historySize, d.incidents.historySize, 1),
+        },
+        correlation: {
+            minCorrelation: num(correlation.minCorrelation, d.correlation.minCorrelation, 0.01, 0.99),
+            alpha: num(correlation.alpha, d.correlation.alpha, 0.0001, 0.5),
+            power: num(correlation.power, d.correlation.power, 0.5, 0.9999),
+            strongThreshold: num(correlation.strongThreshold, d.correlation.strongThreshold, 0, 1),
+            maxLag: num(correlation.maxLag, d.correlation.maxLag, 0),
+            maxWindow: correlationMaxWindow,
+            minCoverage: num(correlation.minCoverage, d.correlation.minCoverage, 0, 1),
+            evaluateEveryIntervals: num(correlation.evaluateEveryIntervals, d.correlation.evaluateEveryIntervals, 1),
+        },
+        dashboard,
+        transport: {
+            socketPath: normalizePath(str(transport.socketPath, d.transport.socketPath)) + '/',
+            cors: typeof transport.cors === 'string' || typeof transport.cors === 'boolean' ? transport.cors : d.transport.cors,
+            pingTimeoutMs: num(transport.pingTimeoutMs, d.transport.pingTimeoutMs, 1000),
+            maxHttpBufferSize: num(transport.maxHttpBufferSize, d.transport.maxHttpBufferSize, 1024),
         },
         publisher: {
-            intervalMs: 1000,
-            slowLatencyThresholdMs: 500,
-            eventLoopLagThresholdMs: 100,
-            eventLoopResolutionMs: 20,
+            intervalMs: num(o.publisher?.intervalMs, d.publisher.intervalMs, 100),
         },
-        tickIntervalMs: 250,
-        excludePaths: [
-            '/_next/*',
-            '/_next/**',
-            '*.map',
-            '*.js',
-            '*.css',
-            '/favicon.ico',
-            '/metrics_pack',
-            '/health',
-            '/optima-metrics/**',
-            '/optima-metrics/*',
-        ], //! OPTIMIZE THIS
-        consoleLog: true,
-        ringBufferSize: 60,
-        alertBufferSize: 100,
-    });
-    constructor() {
-        this.config = this.defaultConfig;
-    }
+        tickIntervalMs: num(o.tickIntervalMs, d.tickIntervalMs, 10),
+        simulation,
+    };
+}
+function toClientConfig(config) {
+    const persistence = config.persistence === false ? false : {
+        persistRawRequests: config.persistence.persistRawRequests,
+        maxBufferSize: config.persistence.maxBufferSize,
+        archiveIntervalMs: config.persistence.archiveIntervalMs,
+        heartbeatIntervalMs: config.persistence.heartbeatIntervalMs,
+        shutdownDrainTimeoutMs: config.persistence.shutdownDrainTimeoutMs,
+    };
+    return {
+        applicationVersion: config.applicationVersion,
+        collection: {
+            bucketIntervalMs: config.collection.bucketIntervalMs,
+            excludePaths: config.collection.excludePaths,
+        },
+        thresholds: config.thresholds,
+        cache: { viewWindowBuckets: config.cache.viewWindowBuckets },
+        persistence,
+        incidents: config.incidents,
+        correlation: config.correlation,
+        dashboard: config.dashboard,
+        publisher: config.publisher,
+        tickIntervalMs: config.tickIntervalMs,
+        simulation: config.simulation,
+    };
+}
+class ConfigManager {
+    static instance;
+    config = deepFreeze(resolve());
+    initialized = false;
+    constructor() { }
     static getInstance() {
         if (!ConfigManager.instance) {
             ConfigManager.instance = new ConfigManager();
@@ -43,67 +271,19 @@ class ConfigManager {
         return ConfigManager.instance;
     }
     initialize(userOptions) {
-        const validated = this.validateAndSanitize(userOptions);
-        this.config = Object.freeze({
-            ...this.defaultConfig,
-            ...validated
-        });
+        if (this.initialized) {
+            if (userOptions !== undefined) {
+                logger_1.default.error('ConfigManager: already initialized, new options are ignored.');
+            }
+            return this.config;
+        }
+        this.config = deepFreeze(resolve(userOptions));
+        this.initialized = true;
         return this.config;
     }
     get() {
         return this.config;
     }
-    validateAndSanitize(options) {
-        if (!options) {
-            return {};
-        }
-        const sanitized = {};
-        if (options.dashboardPath !== undefined) {
-            if (options.dashboardPath === false) {
-                sanitized.dashboardPath = false;
-            }
-            else {
-                sanitized.dashboardPath = String(options.dashboardPath);
-            }
-        }
-        if (options.simulation !== undefined) {
-            if (typeof options.simulation === 'boolean') {
-                sanitized.simulation = options.simulation;
-            }
-            else {
-                sanitized.simulation = {
-                    intervalMs: Math.max(1, options.simulation.intervalMs),
-                    requestsPerTick: Math.max(1, options.simulation.requestsPerTick),
-                };
-            }
-        }
-        if (options.publisher !== undefined) {
-            sanitized.publisher = {
-                intervalMs: Math.max(1, options.publisher.intervalMs),
-                slowLatencyThresholdMs: Math.max(1, options.publisher.slowLatencyThresholdMs),
-                eventLoopLagThresholdMs: Math.max(1, options.publisher.eventLoopLagThresholdMs),
-                eventLoopResolutionMs: options.publisher.eventLoopResolutionMs !== undefined
-                    ? Math.max(1, options.publisher.eventLoopResolutionMs)
-                    : undefined,
-            };
-        }
-        if (options.tickIntervalMs !== undefined) {
-            sanitized.tickIntervalMs = Math.max(1, options.tickIntervalMs);
-        }
-        if (Array.isArray(options.excludePaths)) {
-            sanitized.excludePaths = options.excludePaths.filter(path => typeof path === 'string');
-        }
-        if (options.consoleLog !== undefined) {
-            sanitized.consoleLog = Boolean(options.consoleLog);
-        }
-        if (options.ringBufferSize !== undefined) {
-            sanitized.ringBufferSize = Math.max(1, options.ringBufferSize);
-        }
-        if (options.alertBufferSize !== undefined) {
-            sanitized.alertBufferSize = Math.max(1, options.alertBufferSize);
-        }
-        return sanitized;
-    }
 }
 exports.ConfigManager = ConfigManager;
 const getConfig = () => ConfigManager.getInstance().get();

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

@@ -1,19 +1,95 @@
 export interface ConfigOptions {
-    dashboardPath?: string | false;
-    simulation?: false | {
-        intervalMs: number;
-        requestsPerTick: number;
+    applicationVersion?: string;
+    logging?: {
+        consoleLog?: boolean;
     };
-    publisher?: {
-        intervalMs: number;
-        slowLatencyThresholdMs: number;
-        eventLoopLagThresholdMs: number;
+    collection?: {
+        excludePaths?: string[];
+        includeDefaultExcludes?: boolean;
+        bucketIntervalMs?: number;
+        maxEndpointsPerBucket?: number;
         eventLoopResolutionMs?: number;
     };
+    thresholds?: {
+        slowLatencyMs?: number;
+        eventLoopLagMs?: number;
+    };
+    cache?: {
+        liveBuckets?: number;
+        viewWindowBuckets?: number;
+    };
+    persistence?: false | {
+        baseDir?: string;
+        persistRawRequests?: boolean;
+        maxBufferSize?: number;
+        archiveIntervalMs?: number;
+        heartbeatIntervalMs?: number;
+        shutdownDrainTimeoutMs?: number;
+        writer?: {
+            maxQueue?: number;
+            maxRetries?: number;
+            retryDelayMs?: number;
+        };
+    };
+    incidents?: {
+        windowIntervals?: number;
+        minRequests?: number;
+        serverErrorRate?: number;
+        recoveryRatio?: number;
+        pendingForMs?: number;
+        recoveryForMs?: number;
+        resolvedHoldMs?: number;
+        historySize?: number;
+    };
+    correlation?: {
+        minCorrelation?: number;
+        alpha?: number;
+        power?: number;
+        strongThreshold?: number;
+        maxLag?: number;
+        maxWindow?: number;
+        minCoverage?: number;
+        evaluateEveryIntervals?: number;
+    };
+    dashboard?: false | {
+        path?: string;
+        liveWindow?: number;
+        backfillLimit?: number;
+        maxBackfillAgeMs?: number;
+        topImpactRoutes?: number;
+        analyticsPageSize?: number;
+        sessionSummaryWindowHours?: number;
+    };
+    transport?: {
+        socketPath?: string;
+        cors?: string | boolean;
+        pingTimeoutMs?: number;
+        maxHttpBufferSize?: number;
+    };
+    publisher?: {
+        intervalMs?: number;
+    };
     tickIntervalMs?: number;
-    excludePaths?: string[];
-    consoleLog?: boolean;
-    ringBufferSize?: number;
-    alertBufferSize?: number;
+    simulation?: false | {
+        intervalMs?: number;
+        requestsPerTick?: number;
+    };
 }
-export type ReadonlyConfig = Readonly<Required<ConfigOptions>>;
+type Resolved<T> = T extends false ? false : T extends readonly (infer U)[] ? readonly U[] : T extends object ? {
+    readonly [K in keyof T]-?: Resolved<Exclude<T[K], undefined>>;
+} : T;
+export type ReadonlyConfig = Resolved<ConfigOptions>;
+export type ClientConfig = {
+    applicationVersion: string;
+    collection: Pick<ReadonlyConfig['collection'], 'bucketIntervalMs' | 'excludePaths'>;
+    thresholds: ReadonlyConfig['thresholds'];
+    cache: Pick<ReadonlyConfig['cache'], 'viewWindowBuckets'>;
+    persistence: false | Omit<Exclude<ReadonlyConfig['persistence'], false>, 'baseDir' | 'writer'>;
+    incidents: ReadonlyConfig['incidents'];
+    correlation: ReadonlyConfig['correlation'];
+    dashboard: ReadonlyConfig['dashboard'];
+    publisher: ReadonlyConfig['publisher'];
+    tickIntervalMs: number;
+    simulation: ReadonlyConfig['simulation'];
+};
+export {};

package/dist/core/delivery/buckets-request.d.ts

@@ -0,0 +1,2 @@
+import type { BucketsRequest } from '../domain';
+export declare function parseBucketsRequest(raw: unknown): BucketsRequest | null;

package/dist/core/delivery/buckets-request.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseBucketsRequest = parseBucketsRequest;
+const MAX_ID_LENGTH = 128;
+function parseBucketsRequest(raw) {
+    if (!raw || typeof raw !== 'object')
+        return null;
+    const r = raw;
+    if (typeof r.subscriptionId !== 'string' || r.subscriptionId.length === 0 || r.subscriptionId.length > MAX_ID_LENGTH)
+        return null;
+    const sessionId = typeof r.sessionId === 'string' && r.sessionId.length <= MAX_ID_LENGTH ? r.sessionId : null;
+    const afterSequence = typeof r.afterSequence === 'number' && Number.isInteger(r.afterSequence) && r.afterSequence >= 0
+        ? r.afterSequence : null;
+    const afterEndTime = typeof r.afterEndTime === 'string' && !Number.isNaN(Date.parse(r.afterEndTime))
+        ? r.afterEndTime : null;
+    const limit = typeof r.limit === 'number' && Number.isFinite(r.limit) ? r.limit : undefined;
+    return { subscriptionId: r.subscriptionId, sessionId, afterSequence, afterEndTime, limit };
+}

package/dist/core/delivery/index.d.ts

@@ -1,2 +1,3 @@
 export * from './metrics.publisher';
 export * from './websocket.events';
+export * from './buckets-request';

package/dist/core/delivery/index.js

@@ -16,3 +16,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./metrics.publisher"), exports);
 __exportStar(require("./websocket.events"), exports);
+__exportStar(require("./buckets-request"), exports);

package/dist/core/delivery/metrics.publisher.d.ts

@@ -1,18 +1,31 @@
 import type { WebSocketAdapter } from "../../adapters/websocket.adapter";
-import type { SystemStaticInfo, AnalyticsData, DashboardData, HealthData } from "../domain";
+import type { SystemStaticInfo, AnalyticsData, HealthDetails, SessionRecord, SessionManifest, SessionSummary, AnalyticsFilterSettings, CorrelationData, BucketsMessage, BucketsRequest, IncidentsSnapshot } from "../domain";
 export interface MetricsDataProvider {
     getSystemStaticInfo(): SystemStaticInfo;
-    getDashboardData(): DashboardData;
-    getAnalyticsData(): AnalyticsData;
-    getHealthData(): HealthData;
+    getLiveBuckets(): BucketsMessage | null;
+    getBackFill(req: BucketsRequest): Promise<BucketsMessage>;
+    getAnalyticsData(filters?: AnalyticsFilterSettings): AnalyticsData;
+    getHealthData(): HealthDetails;
+}
+export interface SessionDataProvider {
+    getSessionRecord(): SessionRecord | null;
+    getSessionManifest(): Promise<SessionManifest>;
+    getSessionSummary(sessionNumber: number): Promise<SessionSummary | null>;
+}
+export interface IncidentDataProvider {
+    snapshot(): IncidentsSnapshot;
+}
+export interface CorrelationDataProvider {
+    pack(): CorrelationData;
+    replay(findingId: string): Promise<unknown>;
 }
 export declare class MetricsPublisher {
     private readonly provider;
+    private readonly sessionProvider;
+    private readonly correlationProvider;
+    private readonly incidentProvider;
     private readonly websocket;
-    private readonly intervalMs;
-    private interval?;
-    constructor(provider: MetricsDataProvider, websocket: WebSocketAdapter, intervalMs?: number);
-    start(): void;
-    stop(): void;
-    private publish;
+    private publishData;
+    constructor(provider: MetricsDataProvider, sessionProvider: SessionDataProvider, correlationProvider: CorrelationDataProvider, incidentProvider: IncidentDataProvider, websocket: WebSocketAdapter);
+    publish(): void;
 }