apm-optima 1.0.4 → 2.0.0

package/dist/core/storage/stores/bucket-metric.js

@@ -0,0 +1,168 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HISTOGRAM_BUCKET_COUNT = exports.HISTOGRAM_UPPER_BOUNDS_MS = exports.HISTOGRAM_SCHEMA_ID = exports.BUCKET_SCHEMA_VERSION = void 0;
+exports.createAggregate = createAggregate;
+exports.histogramIndex = histogramIndex;
+exports.recordInto = recordInto;
+exports.mergeInto = mergeInto;
+exports.mergeAggregates = mergeAggregates;
+exports.percentileFromAggregate = percentileFromAggregate;
+exports.countSlowerThan = countSlowerThan;
+exports.deriveMetrics = deriveMetrics;
+exports.emptyRuntime = emptyRuntime;
+exports.mergeRuntimeInto = mergeRuntimeInto;
+exports.deriveRuntime = deriveRuntime;
+exports.deepFreeze = deepFreeze;
+exports.BUCKET_SCHEMA_VERSION = 3;
+exports.HISTOGRAM_SCHEMA_ID = 'lat-v1';
+exports.HISTOGRAM_UPPER_BOUNDS_MS = [
+    5, 10, 15, 20, 25, 30, 40, 50, 60, 70, 80, 90, 100, 120, 140, 160, 180, 200,
+    250, 300, 350, 400, 450, 500, 550, 600, 700, 800, 900, 1000, 1500, 2000, 3000, 5000,
+    10_000, 30_000,
+];
+exports.HISTOGRAM_BUCKET_COUNT = exports.HISTOGRAM_UPPER_BOUNDS_MS.length + 1;
+function createAggregate() {
+    return {
+        requestCount: 0, clientErrorCount: 0, serverErrorCount: 0,
+        durationSumMs: 0, durationMaxMs: null, durationMinMs: null,
+        histogramSchemaId: exports.HISTOGRAM_SCHEMA_ID,
+        histogramCounts: new Array(exports.HISTOGRAM_BUCKET_COUNT).fill(0),
+    };
+}
+function histogramIndex(duration) {
+    let lo = 0, hi = exports.HISTOGRAM_UPPER_BOUNDS_MS.length;
+    while (lo < hi) {
+        const mid = (lo + hi) >> 1;
+        if (duration <= exports.HISTOGRAM_UPPER_BOUNDS_MS[mid])
+            hi = mid;
+        else
+            lo = mid + 1;
+    }
+    return lo;
+}
+function recordInto(agg, durationMs, statusCode) {
+    if (!Number.isFinite(durationMs))
+        return false;
+    const duration = Math.max(0, durationMs);
+    agg.requestCount++;
+    agg.durationSumMs += duration;
+    agg.durationMaxMs = agg.durationMaxMs === null ? duration : Math.max(agg.durationMaxMs, duration);
+    agg.durationMinMs = agg.durationMinMs === null ? duration : Math.min(agg.durationMinMs, duration);
+    if (statusCode >= 400 && statusCode < 500)
+        agg.clientErrorCount++;
+    else if (statusCode >= 500)
+        agg.serverErrorCount++;
+    agg.histogramCounts[histogramIndex(duration)]++;
+    return true;
+}
+const maxN = (a, b) => a === null ? b : b === null ? a : Math.max(a, b);
+const minN = (a, b) => a === null ? b : b === null ? a : Math.min(a, b);
+function mergeInto(t, s) {
+    if (t.histogramSchemaId !== s.histogramSchemaId || t.histogramCounts.length !== s.histogramCounts.length) {
+        throw new Error(`Cannot merge aggregates with different histogram schemas: ${t.histogramSchemaId} vs ${s.histogramSchemaId}`);
+    }
+    t.requestCount += s.requestCount;
+    t.clientErrorCount += s.clientErrorCount;
+    t.serverErrorCount += s.serverErrorCount;
+    t.durationSumMs += s.durationSumMs;
+    t.durationMaxMs = maxN(t.durationMaxMs, s.durationMaxMs);
+    t.durationMinMs = minN(t.durationMinMs, s.durationMinMs);
+    for (let i = 0; i < t.histogramCounts.length; i++)
+        t.histogramCounts[i] += s.histogramCounts[i];
+}
+function mergeAggregates(a, b) {
+    const out = { ...a, histogramCounts: [...a.histogramCounts] };
+    mergeInto(out, b);
+    return out;
+}
+function percentileFromAggregate(agg, q) {
+    if (agg.requestCount === 0)
+        return 0;
+    const target = Math.max(1, Math.ceil(q * agg.requestCount));
+    let cum = 0;
+    for (let i = 0; i < agg.histogramCounts.length; i++) {
+        cum += agg.histogramCounts[i];
+        if (cum >= target) {
+            const upper = i < exports.HISTOGRAM_UPPER_BOUNDS_MS.length ? exports.HISTOGRAM_UPPER_BOUNDS_MS[i] : Number.POSITIVE_INFINITY;
+            return Math.min(upper, agg.durationMaxMs ?? upper);
+        }
+    }
+    return agg.durationMaxMs ?? 0;
+}
+function countSlowerThan(agg, thresholdMs) {
+    let count = 0;
+    for (let i = 0; i < agg.histogramCounts.length; i++) {
+        const lower = i === 0 ? 0 : exports.HISTOGRAM_UPPER_BOUNDS_MS[i - 1];
+        if (lower >= thresholdMs)
+            count += agg.histogramCounts[i];
+    }
+    return count;
+}
+function deriveMetrics(agg, durationMs) {
+    const n = agg.requestCount;
+    return {
+        requestCount: n,
+        rps: durationMs > 0 ? n / (durationMs / 1000) : 0,
+        averageLatency: n > 0 ? agg.durationSumMs / n : 0,
+        minLatency: agg.durationMinMs ?? 0,
+        maxLatency: agg.durationMaxMs ?? 0,
+        p50: percentileFromAggregate(agg, 0.50),
+        p95: percentileFromAggregate(agg, 0.95),
+        p99: percentileFromAggregate(agg, 0.99),
+        errorRate: n > 0 ? (agg.clientErrorCount + agg.serverErrorCount) / n : 0,
+        clientErrorCount: agg.clientErrorCount,
+        serverErrorCount: agg.serverErrorCount,
+    };
+}
+const sumN = (a, b) => a === null ? b : b === null ? a : a + b;
+function emptyRuntime() {
+    return {
+        cpuTimeUs: null, cpuUserUs: null, cpuSystemUs: null,
+        heapUsedBytes: null, heapTotalBytes: null, heapLimitBytes: null, rssBytes: null,
+        eventLoopSampleCount: 0, eventLoopDelaySumMs: null, eventLoopDelayMaxMs: null,
+        gcCount: null, gcDurationSumMs: null,
+    };
+}
+function mergeRuntimeInto(t, s, sIsLater) {
+    t.cpuTimeUs = sumN(t.cpuTimeUs, s.cpuTimeUs);
+    t.cpuUserUs = sumN(t.cpuUserUs, s.cpuUserUs);
+    t.cpuSystemUs = sumN(t.cpuSystemUs, s.cpuSystemUs);
+    t.eventLoopSampleCount += s.eventLoopSampleCount;
+    t.eventLoopDelaySumMs = sumN(t.eventLoopDelaySumMs, s.eventLoopDelaySumMs);
+    t.eventLoopDelayMaxMs = maxN(t.eventLoopDelayMaxMs, s.eventLoopDelayMaxMs);
+    t.gcCount = sumN(t.gcCount, s.gcCount);
+    t.gcDurationSumMs = sumN(t.gcDurationSumMs, s.gcDurationSumMs);
+    if (sIsLater) {
+        t.heapUsedBytes = s.heapUsedBytes;
+        t.heapTotalBytes = s.heapTotalBytes;
+        t.heapLimitBytes = s.heapLimitBytes;
+        t.rssBytes = s.rssBytes;
+    }
+}
+function deriveRuntime(rt, durationMs) {
+    const durationUs = durationMs * 1000;
+    const pct = (us) => us !== null && durationUs > 0 ? (us / durationUs) * 100 : null;
+    return {
+        cpuPercent: pct(rt.cpuTimeUs),
+        cpuUserPercent: pct(rt.cpuUserUs),
+        cpuSystemPercent: pct(rt.cpuSystemUs),
+        eventLoopDelayMeanMs: rt.eventLoopSampleCount > 0 && rt.eventLoopDelaySumMs !== null
+            ? rt.eventLoopDelaySumMs / rt.eventLoopSampleCount : null,
+        eventLoopDelayMaxMs: rt.eventLoopDelayMaxMs,
+        gcCount: rt.gcCount,
+        gcDurationSumMs: rt.gcDurationSumMs,
+        gcPauseAverageMs: rt.gcCount && rt.gcDurationSumMs !== null ? rt.gcDurationSumMs / rt.gcCount : null,
+        heapUsedBytes: rt.heapUsedBytes,
+        heapTotalBytes: rt.heapTotalBytes,
+        heapLimitBytes: rt.heapLimitBytes,
+        rssBytes: rt.rssBytes,
+    };
+}
+function deepFreeze(v) {
+    if (v !== null && typeof v === 'object' && !Object.isFrozen(v)) {
+        Object.freeze(v);
+        for (const x of Object.values(v))
+            deepFreeze(x);
+    }
+    return v;
+}

package/dist/core/storage/stores/bucket-view.d.ts

@@ -0,0 +1,44 @@
+import { type MetricBucket, type EndpointAggregate } from './bucket-metric';
+export interface BucketView {
+    timestamp: number;
+    durationMs: number;
+    quality: string[];
+    rps: {
+        value: number;
+        count: number;
+        perEndpoints: Map<string, number>;
+    };
+    latency: {
+        average: number;
+        p50: number;
+        p95: number;
+        p99: number;
+        max: number;
+        min: number;
+    };
+    error: {
+        rate: number;
+        clientCount: number;
+        serverCount: number;
+    };
+}
+export declare function toBucketView(b: MetricBucket): BucketView;
+export interface EndpointView {
+    method: string;
+    route: string;
+    rps: number;
+    requestCount: number;
+    averageLatency: number;
+    minLatency: number;
+    p50: number;
+    p95: number;
+    p99: number;
+    errorRate: number;
+    impactedRequests: number;
+    status: 'HEALTHY' | 'DEGRADED';
+}
+export interface EndpointSeriesInput {
+    durationMs: number;
+    endpoints?: readonly EndpointAggregate[];
+}
+export declare function deriveEndpointView(buckets: readonly EndpointSeriesInput[], slowLatencyMs: number): EndpointView[];

package/dist/core/storage/stores/bucket-view.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toBucketView = toBucketView;
+exports.deriveEndpointView = deriveEndpointView;
+const bucket_metric_1 = require("./bucket-metric");
+function toBucketView(b) {
+    const m = (0, bucket_metric_1.deriveMetrics)(b.requests, b.durationMs);
+    return {
+        timestamp: Date.parse(b.startTime),
+        durationMs: b.durationMs,
+        quality: b.qualityFlags,
+        rps: {
+            value: m.rps,
+            count: m.requestCount,
+            perEndpoints: new Map(b.endpoints.map(e => [`${e.method}:${e.route}`, e.requestCount])),
+        },
+        latency: {
+            average: m.averageLatency,
+            p50: m.p50,
+            p95: m.p95,
+            p99: m.p99,
+            max: b.requests.durationMaxMs ?? 0,
+            min: b.requests.durationMinMs ?? 0
+        },
+        error: {
+            rate: m.errorRate,
+            clientCount: m.clientErrorCount,
+            serverCount: m.serverErrorCount
+        }
+    };
+}
+function deriveEndpointView(buckets, slowLatencyMs) {
+    const merged = new Map();
+    for (const b of buckets) {
+        for (const e of b.endpoints ?? []) {
+            const key = `${e.method}:${e.route}`;
+            let m = merged.get(key);
+            if (!m) {
+                m = { method: e.method, route: e.route, agg: (0, bucket_metric_1.createAggregate)() };
+                merged.set(key, m);
+            }
+            (0, bucket_metric_1.mergeInto)(m.agg, e);
+        }
+    }
+    const last = buckets[buckets.length - 1];
+    return [...merged.entries()].map(([key, m]) => {
+        const all = (0, bucket_metric_1.deriveMetrics)(m.agg, 1000);
+        const cur = last?.endpoints?.find(e => `${e.method}:${e.route}` === key);
+        return {
+            method: m.method, route: m.route,
+            rps: cur && last ? (0, bucket_metric_1.deriveMetrics)(cur, last.durationMs).rps : 0,
+            requestCount: all.requestCount,
+            averageLatency: all.averageLatency,
+            minLatency: all.minLatency,
+            p50: all.p50,
+            p95: all.p95,
+            p99: all.p99,
+            errorRate: all.errorRate,
+            impactedRequests: all.serverErrorCount + (0, bucket_metric_1.countSlowerThan)(m.agg, slowLatencyMs),
+            status: all.clientErrorCount + all.serverErrorCount > 0 ? 'DEGRADED' : 'HEALTHY',
+        };
+    });
+}

package/dist/core/storage/stores/bucket.store.d.ts

@@ -1,40 +1,43 @@
-import type { EndpointTelemetry } from '../../domain';
-import { HealthStore } from "../stores/health.store";
-import type { EndpointStore } from "../stores/endpoint.store";
-import type { MetricsStore } from "../stores/metrics.store";
-export interface TelemetryBucket {
-    timestamp: number;
-    rps: {
-        count: number;
-        perEndpoints: Map<string, number>;
-    };
-    latency: {
-        average: number;
-        p50: number;
-        p95: number;
-        p99: number;
-    };
-    error: {
-        rate: number;
-        clientCount: number;
-        serverCount: number;
-    };
-    endpoints: EndpointTelemetry[];
-    health: ReturnType<HealthStore["get"]>;
+import { type MetricBucket, type Origin } from './bucket-metric';
+import type { RuntimeStore } from "./runtime.store";
+export interface BucketStoreOptions {
+    sessionId: string;
+    instanceId: string;
+    intervalMs: number;
+    historySize: number;
+    maxEndpoints: number;
+    originProvider?: () => Origin;
 }
 export declare class BucketStore {
-    private readonly endpointStore;
-    private readonly healthStore;
-    private readonly metricsStore;
+    private readonly runtime;
+    private readonly options;
     private readonly history;
-    private currentSecond;
-    private requestCount;
-    private endpointRequests;
-    constructor(endpointStore: EndpointStore, healthStore: HealthStore, metricsStore: MetricsStore, bufferSize?: number);
-    recordRequest(method: string, route: string): void;
-    flush(): void;
-    getHistory(): TelemetryBucket[];
-    latest(): TelemetryBucket | undefined;
-    private reset;
-    private getSecond;
+    private readonly intervalMs;
+    private readonly maxEndpoints;
+    private sequence;
+    private lastCommitted;
+    private readonly committed;
+    private open;
+    private sealed;
+    private _droppedAfterSeal;
+    constructor(runtime: RuntimeStore, options: BucketStoreOptions);
+    record(input: {
+        method: string;
+        route: string;
+        duration: number;
+        statusCode: number;
+        origin?: Origin;
+    }): void;
+    flush(opts?: {
+        force?: boolean;
+        seal?: boolean;
+    }): MetricBucket | null;
+    get instanceId(): string;
+    markCommitted(sequence: number): void;
+    isCommitted(sequence: number): boolean;
+    get lastCommittedSequence(): number;
+    get droppedAfterSeal(): number;
+    getHistory(): MetricBucket[];
+    latest(): MetricBucket | undefined;
+    private openInterval;
 }

package/dist/core/storage/stores/bucket.store.js

@@ -2,74 +2,126 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BucketStore = void 0;
 const utility_1 = require("../utility");
+const bucket_metric_1 = require("./bucket-metric");
 class BucketStore {
-    endpointStore;
-    healthStore;
-    metricsStore;
+    runtime;
+    options;
     history;
-    currentSecond;
-    requestCount;
-    endpointRequests;
-    constructor(endpointStore, healthStore, metricsStore, bufferSize = 60) {
-        this.endpointStore = endpointStore;
-        this.healthStore = healthStore;
-        this.metricsStore = metricsStore;
-        this.history = new utility_1.RingBuffer(bufferSize);
-        this.currentSecond = this.getSecond();
-        this.requestCount = 0;
-        this.endpointRequests = new Map();
+    intervalMs;
+    maxEndpoints;
+    sequence = 0;
+    lastCommitted = 0;
+    committed = new Set();
+    open;
+    sealed = false;
+    _droppedAfterSeal = 0;
+    constructor(runtime, options) {
+        this.runtime = runtime;
+        this.options = options;
+        this.intervalMs = options.intervalMs;
+        this.maxEndpoints = options.maxEndpoints;
+        this.history = new utility_1.RingBuffer(options.historySize);
+        this.open = this.openInterval(Date.now(), process.hrtime.bigint());
     }
-    recordRequest(method, route) {
-        this.requestCount++;
-        const key = `${method}:${route}`;
-        const count = this.endpointRequests.get(key) ?? 0;
-        this.endpointRequests.set(key, count + 1);
-    }
-    flush() {
-        const now = this.getSecond();
-        // same second
-        if (now === this.currentSecond) {
+    record(input) {
+        if (this.sealed) {
+            this._droppedAfterSeal++;
             return;
         }
-        const endpoints = this.endpointStore.all();
-        const metrics = this.metricsStore.snapshot();
-        const bucket = {
-            timestamp: this.currentSecond,
-            rps: {
-                count: this.requestCount,
-                perEndpoints: new Map(this.endpointRequests),
-            },
-            latency: {
-                average: metrics.averageLatency,
-                p50: metrics.latency.p50,
-                p95: metrics.latency.p95,
-                p99: metrics.latency.p99,
-            },
-            error: {
-                rate: metrics.errorRate,
-                clientCount: metrics.errorClientCount,
-                serverCount: metrics.errorServerCount,
-            },
-            endpoints,
-            health: this.healthStore.get(),
-        };
-        this.history.push(bucket);
-        this.reset();
-        this.metricsStore.reset();
-        this.currentSecond = now;
-    }
-    getHistory() {
-        return this.history.values();
+        const cur = this.open;
+        if (!(0, bucket_metric_1.recordInto)(cur.requests, input.duration, input.statusCode))
+            return;
+        const origin = input.origin ?? this.options.originProvider?.() ?? 'real';
+        if (origin === 'synthetic')
+            cur.syntheticSeen = true;
+        else
+            cur.realSeen = true;
+        let key = `${input.method}:${input.route}`;
+        let entry = cur.endpoints.get(key);
+        if (!entry && cur.endpoints.size >= this.maxEndpoints) {
+            cur.flags.add('ENDPOINT_OVERFLOW');
+            key = 'OTHER:__overflow__';
+            entry = cur.endpoints.get(key);
+        }
+        if (!entry) {
+            const overflow = key === 'OTHER:__overflow__';
+            entry = {
+                method: overflow ? 'OTHER' : input.method,
+                route: overflow ? '__overflow__' : input.route,
+                aggregate: (0, bucket_metric_1.createAggregate)()
+            };
+            cur.endpoints.set(key, entry);
+        }
+        (0, bucket_metric_1.recordInto)(entry.aggregate, input.duration, input.statusCode);
     }
-    latest() {
-        return this.history.latest();
+    flush(opts = {}) {
+        if (this.sealed)
+            return null;
+        if (opts.seal)
+            this.sealed = true;
+        const nowHr = process.hrtime.bigint();
+        const cur = this.open;
+        const elapsedMs = Number(nowHr - cur.startHr) / 1e6;
+        if (!opts.force && elapsedMs < this.intervalMs)
+            return null;
+        if (opts.force && elapsedMs < 1 && cur.requests.requestCount === 0)
+            return null;
+        const endWall = Date.now();
+        const flags = new Set(cur.flags);
+        if (elapsedMs > this.intervalMs * 1.5)
+            flags.add('LATE_CLOSE');
+        if (opts.force && elapsedMs < this.intervalMs)
+            flags.add('PARTIAL');
+        if (cur.syntheticSeen && cur.realSeen)
+            flags.add('MIXED_ORIGIN');
+        if (Math.abs((endWall - cur.startWall) - elapsedMs) > 500)
+            flags.add('CLOCK_SKEW');
+        const sequence = ++this.sequence;
+        const origin = cur.syntheticSeen ? 'synthetic' : cur.realSeen ? 'real' : (this.options.originProvider?.() ?? 'real');
+        const runtime = this.runtime.closeInterval();
+        const bucket = (0, bucket_metric_1.deepFreeze)({
+            schemaVersion: bucket_metric_1.BUCKET_SCHEMA_VERSION,
+            bucketId: `${this.options.sessionId}:${sequence}`,
+            sessionId: this.options.sessionId,
+            instanceId: this.options.instanceId,
+            sequence,
+            startTime: new Date(cur.startWall).toISOString(),
+            endTime: new Date(endWall).toISOString(),
+            durationMs: Math.round(elapsedMs * 1000) / 1000,
+            origin,
+            requests: cur.requests,
+            runtime,
+            endpoints: [...cur.endpoints.values()].map(e => ({ method: e.method, route: e.route, ...e.aggregate })),
+            qualityFlags: [...flags],
+        });
+        this.history.push(bucket);
+        this.open = this.openInterval(endWall, nowHr);
+        return bucket;
     }
-    reset() {
-        this.requestCount = 0;
-        this.endpointRequests.clear();
+    get instanceId() { return this.options.instanceId; }
+    markCommitted(sequence) {
+        this.committed.add(sequence);
+        if (sequence > this.lastCommitted)
+            this.lastCommitted = sequence;
+        const oldest = this.history.values()[0]?.sequence ?? sequence;
+        for (const s of this.committed)
+            if (s < oldest)
+                this.committed.delete(s);
     }
-    getSecond() {
-        return (Math.floor(Date.now() / 1000) * 1000);
+    isCommitted(sequence) { return this.committed.has(sequence); }
+    get lastCommittedSequence() { return this.lastCommitted; }
+    get droppedAfterSeal() { return this._droppedAfterSeal; }
+    getHistory() { return this.history.values(); }
+    latest() { return this.history.latest(); }
+    openInterval(startWall, startHr) {
+        return {
+            startHr, startWall,
+            requests: (0, bucket_metric_1.createAggregate)(),
+            endpoints: new Map(),
+            flags: new Set(),
+            syntheticSeen: false,
+            realSeen: false
+        };
     }
 }
 exports.BucketStore = BucketStore;

package/dist/core/storage/stores/dashboard.store.d.ts

@@ -1,15 +1,22 @@
-import type { DashboardData } from '../../domain';
+import type { DashboardData, DashboardTickData } from '../../domain';
 import type { BucketStore } from './bucket.store';
 import type { HealthStore } from './health.store';
-import type { EndpointStore } from './endpoint.store';
 import type { AlertStore } from './alert.store';
 declare class DashboardStore {
     private readonly buckets;
     private readonly health;
-    private readonly endpoints;
     private readonly alerts;
-    constructor(buckets: BucketStore, health: HealthStore, endpoints: EndpointStore, alerts: AlertStore);
+    constructor(buckets: BucketStore, health: HealthStore, alerts: AlertStore);
+    private metrics;
+    private buildCurrent;
+    private buildHistory;
+    private buildHistoryTick;
+    private buildCharts;
+    private buildChartsTick;
     get(): DashboardData;
+    getTickData(): DashboardTickData;
+    private fillRest;
+    private getTotalRequestCount;
     private getImpactEndpoints;
 }
 export { DashboardStore };