apm-optima 1.0.4 → 2.0.0

package/dist/core/telemetry/correlation.service.js

@@ -1,72 +1,264 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.correlationService = void 0;
-const local_repository_1 = require("../storage/local.repository");
+exports.CorrelationService = void 0;
 const statistics_1 = require("../utility/statistics");
+const logger_1 = __importDefault(require("./logger"));
+const correlation_replay_1 = require("./utility/correlation-replay");
+const correlation_finding_1 = require("./utility/correlation-finding");
+const correlation_input_1 = require("./utility/correlation-input");
+const TRANSFORM = 'raw';
+const SCOPES = [{}];
 class CorrelationService {
-    sampleSize;
-    constructor() {
-        this.sampleSize =
-            (0, statistics_1.calculateSampleSizeProportion)(0.05, 0.95); //! This maybe from config?
+    requiredSampleSize;
+    parameters;
+    deps;
+    transform;
+    scopes;
+    analysisIntervalMs;
+    evaluateEvery;
+    busy = false;
+    lastRunAt = Number.NEGATIVE_INFINITY;
+    lastEvaluated = new Map();
+    results = [];
+    lowCoverage = new Set();
+    assessment = {
+        status: 'INSUFFICIENT_DATA',
+        evidence: [],
+        recommendation: 'Analysis not yet started.'
+    };
+    constructor(deps, options) {
+        this.deps = deps;
+        this.requiredSampleSize = (0, statistics_1.calculateSampleSizeCorrelation)(options.minCorrelation, options.alpha, options.power);
+        this.parameters = {
+            requiredSampleSize: this.requiredSampleSize,
+            minCorrelation: options.minCorrelation,
+            alpha: options.alpha,
+            power: options.power,
+            strongThreshold: options.strongThreshold,
+            maxLag: options.maxLag,
+            maxWindow: Math.max(options.maxWindow, this.requiredSampleSize),
+            minCoverage: options.minCoverage,
+            gapPolicy: 'compact',
+        };
+        this.transform = TRANSFORM;
+        this.scopes = SCOPES;
+        this.analysisIntervalMs = options.analysisIntervalMs;
+        this.evaluateEvery = options.evaluateEveryIntervals;
+    }
+    getResults() { return this.results; }
+    getAssessment() { return this.assessment; }
+    pack() { return { results: this.results, assessment: this.assessment }; }
+    tick(now = Date.now()) {
+        if (this.busy)
+            return;
+        if (now - this.lastRunAt < this.analysisIntervalMs)
+            return;
+        this.lastRunAt = now;
+        this.busy = true;
+        this.evaluate(now)
+            .catch(err => logger_1.default.error('Correlation evaluation failed:', err))
+            .finally(() => { this.busy = false; });
     }
-    tick() {
-        const totalHistory = local_repository_1.storage.bucket.getHistory();
-        const size = totalHistory.length;
-        if (size < this.sampleSize) {
+    async evaluate(now) {
+        const sessionId = this.deps.identity.sessionId();
+        let dashboardFindings = [];
+        const durable = this.deps.finding.durable;
+        const consistency = durable ? 'committed' : 'live';
+        const bounds = this.deps.queries.latestWindow(this.parameters.maxWindow, consistency);
+        if (!bounds)
             return;
+        const endSequence = bounds.sequenceTo;
+        for (let s = 0; s < this.scopes.length; s++) {
+            const scope = this.scopes[s];
+            const due = correlation_input_1.PAIRS.filter(pair => {
+                const last = this.lastEvaluated.get(this.seriesFor(sessionId, scope, pair));
+                return last === undefined || endSequence - last >= this.evaluateEvery;
+            });
+            if (due.length === 0)
+                continue;
+            const result = await this.deps.queries.query({
+                sessionId,
+                from: bounds.from,
+                to: bounds.to,
+                method: scope.method,
+                route: scope.route,
+                consistency,
+            });
+            const points = result.points.filter(p => p.sequenceFrom >= bounds.sequenceFrom && p.sequenceTo <= endSequence);
+            if (points.length === 0)
+                continue;
+            const findings = [];
+            for (const pair of due) {
+                const series = this.seriesFor(sessionId, scope, pair);
+                this.lastEvaluated.set(series, endSequence);
+                try {
+                    findings.push(this.buildFinding(sessionId, scope, pair, points, now));
+                }
+                catch (err) {
+                    logger_1.default.error(`Correlation analysis failed for ${(0, correlation_input_1.pairId)(pair.x, pair.y)}:`, err);
+                }
+            }
+            let committed;
+            if (durable) {
+                const saved = await Promise.all(findings.map(f => this.deps.finding.save(f).catch(() => false)));
+                committed = findings.filter((f, i) => {
+                    if (!saved[i])
+                        logger_1.default.error(`Correlation finding not persisted, not published: ${f.findingId}`);
+                    return saved[i];
+                });
+            }
+            else {
+                committed = findings.map(f => ({ ...f, qualityFlags: [...f.qualityFlags, 'NOT_PERSISTED'].sort() }));
+            }
+            if (s === 0)
+                dashboardFindings = committed;
         }
-        const rps = totalHistory.map(e => e.rps.count);
-        const errorRate = totalHistory.map(e => e.error.rate);
-        const heapUsage = totalHistory.map(e => e.health.memory.heapUsage);
-        const p95Latency = totalHistory.map(e => e.latency.p95);
-        const eventLoopLag = totalHistory.map(e => e.health.eventLoop.lag);
-        const averageLatency = totalHistory.map(e => e.latency.average);
-        // 1. eventLoopLag <-> p95 latency
-        this.handleReport(this.testCorrelation(eventLoopLag, p95Latency));
-        // 2. eventLoopLag <-> average latency
-        this.handleReport(this.testCorrelation(eventLoopLag, averageLatency));
-        // 3. heapUsage <-> eventLoopLag
-        this.handleReport(this.testCorrelation(heapUsage, eventLoopLag));
-        // 4. heapUsage <-> p95 latency
-        this.handleReport(this.testCorrelation(heapUsage, p95Latency));
-        // 5. rps <-> errorRate
-        this.handleReport(this.testCorrelation(rps, errorRate));
-        // 6. rps <-> latency
-        this.handleReport(this.testCorrelation(rps, averageLatency));
+        if (dashboardFindings.length > 0)
+            this.publish(dashboardFindings);
+    }
+    seriesFor(sessionId, scope, pair) {
+        return (0, correlation_finding_1.seriesKey)({
+            sessionId, scope, pairId: (0, correlation_input_1.pairId)(pair.x, pair.y), resolutionMs: null,
+            transform: this.transform, parameters: this.parameters,
+        });
+    }
+    buildFinding(sessionId, scope, pair, points, now) {
+        const pid = (0, correlation_input_1.pairId)(pair.x, pair.y);
+        const prepared = (0, correlation_input_1.prepareSeries)(points, pair, this.transform, this.parameters.minCoverage);
+        const result = (0, correlation_input_1.runAnalysis)(prepared, pair, this.parameters);
+        const endSequence = prepared.windowEndSequence;
+        const key = (0, correlation_finding_1.evaluationKey)(this.seriesFor(sessionId, scope, pair), endSequence, prepared.digest);
+        return {
+            findingId: (0, correlation_finding_1.findingIdFor)({ sessionId, scope, pairId: pid, windowEndSequence: endSequence, evaluationKey: key }),
+            evaluationKey: key,
+            sessionId,
+            instanceId: this.deps.identity.instanceId,
+            scope,
+            metricX: pair.x,
+            metricY: pair.y,
+            windowStart: prepared.windowStart,
+            windowEnd: prepared.windowEnd,
+            resolutionMs: null,
+            transform: this.transform,
+            methodVersion: correlation_finding_1.CORRELATION_METHOD_VERSION,
+            parameters: this.parameters,
+            input: {
+                sessionId,
+                bucketCount: prepared.bucketCount,
+                ranges: prepared.ranges,
+                digest: prepared.digest,
+            },
+            inputSchemaVersion: correlation_finding_1.INPUT_SCHEMA_VERSION,
+            createdAt: new Date(now).toISOString(),
+            source: 'live',
+            validPairCount: prepared.validPairCount,
+            droppedPairCount: prepared.droppedPairCount,
+            coverage: prepared.coverage,
+            qualityFlags: prepared.qualityFlags,
+            result,
+        };
+    }
+    async replay(findingId) {
+        const finding = await this.deps.finding.find(findingId);
+        if (!finding)
+            return { status: 'NOT_FOUND', findingId };
+        return (0, correlation_replay_1.verifyFinding)(this.deps.queries, finding);
     }
-    testCorrelation(x, y) {
-        const pearsonR = (0, statistics_1.pearsonCorrelation)(x, y);
-        const spearmanR = (0, statistics_1.spearmanCorrelation)(x, y);
-        const { determination, alienation } = (0, statistics_1.determinationAndAlienation)(pearsonR);
-        if (Math.abs(spearmanR) > 0.7 && Math.abs(pearsonR) <= 0.6) {
+    publish(findings) {
+        const byId = new Map(findings.map(f => [`${f.metricX}->${f.metricY}`, f]));
+        const results = [];
+        const lowCoverage = new Set();
+        for (const pair of correlation_input_1.PAIRS) {
+            const id = (0, correlation_input_1.pairId)(pair.x, pair.y);
+            const f = byId.get(id);
+            if (!f)
+                continue;
+            if (f.qualityFlags.includes('LOW_COVERAGE'))
+                lowCoverage.add(id);
+            results.push(this.toUiResult(pair, f));
+        }
+        this.results = results;
+        this.lowCoverage = lowCoverage;
+        this.assessment = this.assess(results);
+    }
+    toUiResult(pair, f) {
+        const x = correlation_input_1.METRICS[pair.x];
+        const y = correlation_input_1.METRICS[pair.y];
+        const unexpectedDirection = f.result.direction !== 'NONE' && f.result.direction !== pair.expectedDirection;
+        return {
+            id: (0, correlation_input_1.pairId)(pair.x, pair.y),
+            xLabel: x.label,
+            yLabel: y.label,
+            expectedDirection: pair.expectedDirection,
+            unexpectedDirection,
+            analysis: unexpectedDirection
+                ? { ...f.result, recommendation: `${f.result.recommendation} The direction of the correlation is opposite to the expected one.` }
+                : f.result,
+            findingId: f.findingId,
+        };
+    }
+    isStrongPositive(id, results) {
+        if (this.lowCoverage.has(id))
+            return false;
+        const result = results.find(r => r.id === id);
+        if (!result)
+            return false;
+        const { status, direction } = result.analysis;
+        return (status === 'STRONG_LINEAR_ASSOCIATION' || status === 'STRONG_MONOTONIC_NONLINEAR_ASSOCIATION')
+            && direction === 'POSITIVE';
+    }
+    assess(results) {
+        const coreId = (0, correlation_input_1.pairId)('rps', 'p95Latency');
+        const core = results.find(r => r.id === coreId);
+        if (!core || core.analysis.status === 'INSUFFICIENT_DATA' || this.lowCoverage.has(coreId)) {
             return {
-                status: 'NON_LINEAR_BURST',
-                recommendation: 'Kritično! Detektovan nelinearan (eksponencijalni) skok. Sistem ulazi u zonu zasićenja resursa.'
+                status: 'INSUFFICIENT_DATA',
+                evidence: [],
+                recommendation: 'No sufficient data to assess the saturation pattern.'
             };
         }
-        else if (spearmanR > 0.7 && determination > 0.5) {
-            if (alienation > 0.4) {
-                return {
-                    status: 'EXTERNAL_INFLUENCE',
-                    recommendation: `Uočena je povezanost (r=${spearmanR.toFixed(2)}), ali eksterni faktori utiču sa ${(alienation * 100).toFixed(1)}%. Ne donositi ishitren zaključak o uzročnosti.`
-                };
-            }
-            else {
-                return {
-                    status: 'SYSTEMIC_LINEAR_DEGRADATION',
-                    recommendation: `Linearna degradacija. Varijable zajednički rastu.`
-                };
+        const supporting = [
+            { id: (0, correlation_input_1.pairId)('eventLoopLag', 'p95Latency'), text: 'Event Loop Lag ↔ p95 Latency' },
+            { id: (0, correlation_input_1.pairId)('rps', 'errorRate'), text: 'RPS ↔ error rate' }
+        ];
+        const evidence = [];
+        if (this.isStrongPositive(coreId, results)) {
+            evidence.push('RPS ↔ p95 Latency');
+            for (const item of supporting) {
+                if (this.isStrongPositive(item.id, results))
+                    evidence.push(item.text);
             }
         }
+        if (evidence.length >= 2) {
+            return {
+                status: 'POSSIBLE_SATURATION',
+                evidence,
+                recommendation: `Possible saturation pattern: in the observed period there is a strong positive correlation (${evidence.join('; ')}). Correlation does not prove causality; check CPU, GC and external dependencies.`
+            };
+        }
         return {
-            status: 'STABLE',
-            recommendation: 'Sistem je stabilan. Nema detektovanih uzročnih veza između posmatranih varijabli.'
+            status: 'NO_SATURATION_PATTERN',
+            evidence,
+            recommendation: 'In the observed period, no pattern indicating saturation was detected.'
         };
     }
-    handleReport(report) {
-        if (report.status === 'STABLE')
-            return;
-        local_repository_1.storage.alerts.warning(report.recommendation);
+    relatedFindings(metric) {
+        return this.results
+            .filter(r => {
+            const [x, y] = r.id.split('->');
+            return (x === metric || y === metric) && !this.lowCoverage.has(r.id)
+                && (r.analysis.status === 'STRONG_LINEAR_ASSOCIATION' || r.analysis.status === 'STRONG_MONOTONIC_NONLINEAR_ASSOCIATION');
+        })
+            .map(r => ({
+            findingId: r.findingId,
+            pairId: r.id,
+            status: String(r.analysis.status),
+            direction: String(r.analysis.direction),
+            pearsonR: r.analysis.pearsonR,
+        }));
     }
 }
-exports.correlationService = new CorrelationService();
+exports.CorrelationService = CorrelationService;

package/dist/core/telemetry/dashboard-live.service.d.ts

@@ -0,0 +1,10 @@
+import type { TelemetryQueryService, SeriesPoint } from './telemetry-query.service';
+import type { BucketsMessage, BucketsRequest, LiveBucketDto } from '../domain';
+export declare function toLiveBucketDto(sessionId: string, p: SeriesPoint): LiveBucketDto;
+export declare class DashboardLiveService {
+    private readonly queries;
+    private readonly currentSessionId;
+    constructor(queries: TelemetryQueryService, currentSessionId: () => string);
+    getLive(): BucketsMessage | null;
+    getBackFill(req: BucketsRequest): Promise<BucketsMessage>;
+}

package/dist/core/telemetry/dashboard-live.service.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DashboardLiveService = void 0;
+exports.toLiveBucketDto = toLiveBucketDto;
+const bucket_metric_1 = require("../storage/stores/bucket-metric");
+const LIVE_WINDOW = 5;
+const DEFAULT_BACKFILL_LIMIT = 120;
+const MAX_BACKFILL_LIMIT = 600;
+const FALLBACK_BACKFILL_MS = 10 * 60_000;
+const MAX_BACKFILL_AGE_MS = 60 * 60_000;
+function toLiveBucketDto(sessionId, p) {
+    const m = (0, bucket_metric_1.deriveMetrics)(p.requests, p.durationMs);
+    return {
+        bucketId: `${sessionId}:${p.sequenceTo}`,
+        sequence: p.sequenceTo,
+        startTime: p.startTime,
+        endTime: p.endTime,
+        durationMs: p.durationMs,
+        committed: p.committed === true,
+        qualityFlags: p.qualityFlags,
+        requestCount: m.requestCount,
+        clientErrorCount: m.clientErrorCount,
+        serverErrorCount: m.serverErrorCount,
+        rps: m.rps,
+        averageLatencyMs: m.averageLatency,
+        p50Ms: m.p50,
+        p95Ms: m.p95,
+        p99Ms: m.p99,
+        errorRate: m.errorRate,
+        runtime: {
+            eventLoopLagMs: p.runtime.loopDelay.meanMs,
+            heapUsageBytes: p.runtime.memoryUsage.heapUsage,
+            heapSizeBytes: p.runtime.memoryUsage.heapSize,
+            rssMemoryBytes: p.runtime.memoryUsage.rssMemory,
+            heapLimitBytes: p.runtime.memoryUsage.heapLimit,
+        },
+    };
+}
+class DashboardLiveService {
+    queries;
+    currentSessionId;
+    constructor(queries, currentSessionId) {
+        this.queries = queries;
+        this.currentSessionId = currentSessionId;
+    }
+    // for publishing, sinhronous, returns the latest live buckets message from RAM
+    getLive() {
+        const sessionId = this.currentSessionId();
+        const result = this.queries.recent(LIVE_WINDOW, { consistency: 'live' });
+        if (result.points.length === 0)
+            return null;
+        const buckets = result.points.map(p => toLiveBucketDto(sessionId, p));
+        return {
+            subscriptionId: null,
+            sessionId,
+            kind: 'live',
+            buckets,
+            lastSequence: buckets[buckets.length - 1].sequence,
+            requestedAfterSequence: null,
+            gaps: [],
+            truncated: false,
+            serverTime: new Date().toISOString(),
+        };
+    }
+    // for backfill, asynchronous, returns the requested live buckets message from storage 
+    // called on loading, reconnecting, filling gaps, etc.
+    async getBackFill(req) {
+        const sessionId = this.currentSessionId();
+        const limit = Math.min(Math.max(1, req.limit ?? DEFAULT_BACKFILL_LIMIT), MAX_BACKFILL_LIMIT);
+        const after = req.sessionId === sessionId ? req.afterSequence : null;
+        let points = [];
+        let gaps = [];
+        let truncated = false;
+        if (after === null) {
+            points = this.queries.recent(limit, { consistency: 'live' }).points;
+        }
+        else {
+            const now = Date.now();
+            const requestedFrom = req.afterEndTime ? Date.parse(req.afterEndTime) : now - FALLBACK_BACKFILL_MS;
+            const from = new Date(Math.max(requestedFrom, now - MAX_BACKFILL_AGE_MS));
+            const result = await this.queries.query({
+                sessionId,
+                from: from.toISOString(),
+                to: new Date(now).toISOString(),
+                consistency: 'live'
+            });
+            points = result.points.filter(p => p.sequenceTo > after);
+            if (points.length > limit) {
+                truncated = true;
+                points = points.slice(-limit);
+            }
+            gaps = result.issues
+                .filter((i) => i.type === 'GAP')
+                .map(i => [i.fromSequence, i.toSequence]);
+        }
+        const buckets = points.map(p => toLiveBucketDto(sessionId, p));
+        return {
+            subscriptionId: req.subscriptionId,
+            sessionId,
+            kind: 'backfill',
+            buckets,
+            lastSequence: buckets.length ? buckets[buckets.length - 1].sequence : null,
+            requestedAfterSequence: after,
+            gaps,
+            truncated,
+            serverTime: new Date().toISOString(),
+        };
+    }
+}
+exports.DashboardLiveService = DashboardLiveService;

package/dist/core/telemetry/dashboard.service.d.ts

@@ -0,0 +1,20 @@
+import type { TelemetryQueryService, SeriesPoint } from './telemetry-query.service';
+import type { BucketsMessage, BucketsRequest, LiveBucketDto } from '../domain';
+export interface DashboardServiceOptions {
+    liveWindow: number;
+    backfillLimit: number;
+    maxBackfillAgeMs: number;
+}
+export declare function toLiveBucketDto(sessionId: string, p: SeriesPoint): LiveBucketDto;
+export declare class DashboardService {
+    private readonly queries;
+    private readonly currentSessionId;
+    private readonly options;
+    constructor(queries: TelemetryQueryService, currentSessionId: () => string, options: DashboardServiceOptions);
+    /**
+     * Get the latest live buckets message from RAM
+     * @returns BucketsMessage | null
+     */
+    getLive(): BucketsMessage | null;
+    getBackFill(req: BucketsRequest): Promise<BucketsMessage>;
+}

package/dist/core/telemetry/dashboard.service.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DashboardService = void 0;
+exports.toLiveBucketDto = toLiveBucketDto;
+const bucket_metric_1 = require("../storage/stores/bucket-metric");
+const MAX_BACKFILL_LIMIT = 600;
+const FALLBACK_BACKFILL_MS = 10 * 60_000;
+function toLiveBucketDto(sessionId, p) {
+    const m = (0, bucket_metric_1.deriveMetrics)(p.requests, p.durationMs);
+    const rt = (0, bucket_metric_1.deriveRuntime)(p.runtime, p.durationMs);
+    return {
+        bucketId: `${sessionId}:${p.sequenceTo}`,
+        sequence: p.sequenceTo,
+        startTime: p.startTime,
+        endTime: p.endTime,
+        durationMs: p.durationMs,
+        committed: p.committed === true,
+        qualityFlags: p.qualityFlags,
+        requestCount: m.requestCount,
+        clientErrorCount: m.clientErrorCount,
+        serverErrorCount: m.serverErrorCount,
+        rps: m.rps,
+        averageLatencyMs: m.averageLatency,
+        p50Ms: m.p50,
+        p95Ms: m.p95,
+        p99Ms: m.p99,
+        errorRate: m.errorRate,
+        runtime: {
+            eventLoopLagMs: rt.eventLoopDelayMeanMs ?? 0,
+            heapUsageBytes: rt.heapUsedBytes ?? 0,
+            heapSizeBytes: rt.heapTotalBytes ?? 0,
+            rssMemoryBytes: rt.rssBytes ?? 0,
+            heapLimitBytes: rt.heapLimitBytes ?? 0,
+            cpuPercent: rt.cpuPercent ?? 0,
+            cpuUserPercent: rt.cpuUserPercent ?? 0,
+            cpuSystemPercent: rt.cpuSystemPercent ?? 0,
+        }
+    };
+}
+class DashboardService {
+    queries;
+    currentSessionId;
+    options;
+    constructor(queries, currentSessionId, options) {
+        this.queries = queries;
+        this.currentSessionId = currentSessionId;
+        this.options = options;
+    }
+    /**
+     * Get the latest live buckets message from RAM
+     * @returns BucketsMessage | null
+     */
+    getLive() {
+        const sessionId = this.currentSessionId();
+        const result = this.queries.recent(this.options.liveWindow, { consistency: 'live' });
+        if (result.points.length === 0)
+            return null;
+        const buckets = result.points.map(p => toLiveBucketDto(sessionId, p));
+        return {
+            subscriptionId: null,
+            sessionId,
+            kind: 'live',
+            buckets,
+            lastSequence: buckets[buckets.length - 1].sequence,
+            requestedAfterSequence: null,
+            gaps: [],
+            truncated: false,
+            serverTime: new Date().toISOString(),
+        };
+    }
+    async getBackFill(req) {
+        const sessionId = this.currentSessionId();
+        const limit = Math.min(Math.max(1, Math.floor(req.limit ?? this.options.backfillLimit)), MAX_BACKFILL_LIMIT);
+        const after = req.sessionId === sessionId && typeof req.afterSequence === 'number' && req.afterSequence >= 0
+            ? Math.floor(req.afterSequence) : null;
+        const message = (points, gaps, truncated) => {
+            const buckets = points.map(p => toLiveBucketDto(sessionId, p));
+            return {
+                subscriptionId: req.subscriptionId,
+                sessionId,
+                kind: 'backfill',
+                buckets,
+                lastSequence: buckets.length ? buckets[buckets.length - 1].sequence : null,
+                requestedAfterSequence: after,
+                gaps,
+                truncated,
+                serverTime: new Date().toISOString(),
+            };
+        };
+        const newest = this.queries.latestWindow(1, 'live');
+        if (!newest)
+            return message([], [], false);
+        if (after === null) {
+            const result = this.queries.recent(limit, { consistency: 'live' });
+            return message(result.points, gapsOf(result.issues), false);
+        }
+        if (after >= newest.sequenceTo)
+            return message([], [], false);
+        const now = Date.now();
+        const known = this.queries.liveBucket(after)?.endTime
+            ?? this.queries.liveBucket(after + 1)?.startTime
+            ?? req.afterEndTime;
+        const requestedFrom = known ? Date.parse(known) : now - FALLBACK_BACKFILL_MS;
+        const from = Math.max(Number.isNaN(requestedFrom) ? now - FALLBACK_BACKFILL_MS : requestedFrom, now - this.options.maxBackfillAgeMs);
+        const result = await this.queries.query({
+            sessionId,
+            from: new Date(from).toISOString(),
+            to: newest.to,
+            consistency: 'live',
+        });
+        let points = result.points.filter(p => p.sequenceFrom > after && p.sequenceTo <= newest.sequenceTo);
+        let truncated = false;
+        if (points.length > limit) {
+            truncated = true;
+            points = points.slice(0, limit);
+        }
+        const sourceFailed = result.issues.some(i => i.type === 'SOURCE_ERROR');
+        const upper = truncated ? points[points.length - 1].sequenceTo : newest.sequenceTo;
+        const gaps = sourceFailed ? [] : missingRanges(after + 1, upper, points);
+        return message(points, gaps, truncated);
+    }
+}
+exports.DashboardService = DashboardService;
+function gapsOf(issues) {
+    return issues
+        .filter((i) => i.type === 'GAP')
+        .map(i => [i.fromSequence, i.toSequence]);
+}
+function missingRanges(from, to, points) {
+    const ranges = [];
+    let next = from;
+    for (const p of [...points].sort((a, b) => a.sequenceFrom - b.sequenceFrom)) {
+        if (p.sequenceFrom > next)
+            ranges.push([next, Math.min(p.sequenceFrom - 1, to)]);
+        next = Math.max(next, p.sequenceTo + 1);
+    }
+    if (next <= to)
+        ranges.push([next, to]);
+    return ranges;
+}

package/dist/core/telemetry/incident.service.d.ts

@@ -0,0 +1,71 @@
+import type { MetricsQueryResult, TelemetryQueryService } from './telemetry-query.service';
+import type { ApplicationEventType, IncidentSeverity, IncidentState, IncidentsSnapshot, RelatedFinding } from '../domain';
+export interface Observation {
+    valid: boolean;
+    value: number | null;
+    reason?: string;
+    endMs: number;
+}
+export interface IncidentTiming {
+    pendingForMs: number;
+    recoveryForMs: number;
+    resolvedHoldMs: number;
+}
+export interface RuleTracker {
+    state: IncidentState;
+    sinceMs: number | null;
+    breachStartMs: number | null;
+    recoveryStartMs: number | null;
+}
+export interface IncidentRule {
+    id: string;
+    title: string;
+    metric: string;
+    unit: string;
+    severity: IncidentSeverity;
+    threshold: number;
+    recoverBelow: number;
+    measure(window: MetricsQueryResult): Omit<Observation, 'endMs'>;
+}
+export declare const initialTracker: () => RuleTracker;
+export declare function stepRule(t: RuleTracker, obs: Observation, rule: Pick<IncidentRule, 'threshold' | 'recoverBelow'>, timing: IncidentTiming): RuleTracker;
+export interface IncidentRuleOptions {
+    windowIntervals?: number;
+    minRequests?: number;
+    serverErrorRate?: number;
+    p95LatencyMs?: number;
+    eventLoopLagMs?: number;
+    recoveryRatio?: number;
+}
+export declare function defaultIncidentRules(o: Required<IncidentRuleOptions>): IncidentRule[];
+export declare const CAUSE_NOTE = "Related findings show which metrics changed together during the incident. Correlation does not establish the cause.";
+export interface IncidentServiceDeps {
+    queries: TelemetryQueryService;
+    sessionId: () => string;
+    durable: () => boolean;
+    related?: (metric: string) => RelatedFinding[];
+    emit?: (event: {
+        type: ApplicationEventType;
+        reason: string;
+        details: Record<string, unknown>;
+    }) => unknown;
+}
+export interface IncidentServiceOptions extends Required<IncidentRuleOptions>, IncidentTiming {
+    historySize: number;
+    rules?: IncidentRule[];
+}
+export declare class IncidentService {
+    private readonly deps;
+    private readonly timing;
+    private readonly windowIntervals;
+    private readonly historySize;
+    private readonly entries;
+    private history;
+    private lastSequence;
+    private lastSessionId;
+    constructor(deps: IncidentServiceDeps, options: IncidentServiceOptions);
+    tick(): void;
+    evaluate(): boolean;
+    snapshot(): IncidentsSnapshot;
+    private apply;
+}