apm-optima 1.0.5 → 2.0.0

package/dist/core/storage/utility/session-registry.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionRegistry = void 0;
+const crypto_1 = require("crypto");
+const index_1 = require("./index");
+const emptyManifest = () => ({ version: 2, sessions: [] });
+class SessionRegistry {
+    manifestPath;
+    writer;
+    manifest = emptyManifest();
+    dirty = false;
+    _current = null;
+    _recoveredFromCrash = false;
+    constructor(manifestPath, writer) {
+        this.manifestPath = manifestPath;
+        this.writer = writer;
+    }
+    get current() { return this._current; }
+    get all() { return this.manifest.sessions; }
+    get recoveredFromCrash() { return this._recoveredFromCrash; }
+    async start() {
+        const raw = await (0, index_1.tryOrDefault)(() => (0, index_1.readJSON)(this.manifestPath), null);
+        this.manifest = this.migrate(raw);
+        for (const s of this.manifest.sessions) {
+            if (s.status === 'RUNNING') {
+                s.status = 'INTERRUPTED';
+                s.endedAt = s.lastPersistedAt ?? s.startedAt;
+                this._recoveredFromCrash = true;
+            }
+        }
+        const number = this.manifest.sessions.reduce((m, s) => Math.max(m, s.sessionNumber), 0) + 1;
+        this._current = {
+            sessionId: (0, crypto_1.randomUUID)(),
+            sessionNumber: number,
+            startedAt: new Date().toISOString(),
+            endedAt: null,
+            lastPersistedAt: null,
+            lastCommitedSequence: 0,
+            status: 'RUNNING',
+        };
+        this.manifest.sessions.push(this._current);
+        await this.save('manifest: session start');
+        return this._current;
+    }
+    notePersisted() {
+        if (!this._current)
+            return;
+        this._current.lastPersistedAt = new Date().toISOString();
+        this._current.lastCommitedSequence = this.writer.commitedSequence;
+        this.dirty = true;
+    }
+    async heartbeat() {
+        if (!this.dirty)
+            return;
+        this.dirty = false;
+        await this.save('manifest: heartbeat').catch(() => { this.dirty = true; });
+    }
+    async complete() {
+        if (!this._current)
+            return;
+        await this.writer.whenIdle();
+        const now = new Date().toISOString();
+        this._current.status = 'COMPLETED';
+        this._current.endedAt = now;
+        this._current.lastPersistedAt = now;
+        this._current.lastCommitedSequence = this.writer.commitedSequence;
+        await this.save('manifest: session complete');
+    }
+    static windowEnd(s) {
+        return s.status === 'RUNNING' ? null : (s.endedAt ?? s.lastPersistedAt);
+    }
+    save(description) {
+        const snapshot = structuredClone(this.manifest);
+        return this.writer.enqueueTask(description, () => (0, index_1.writeJSONAtomic)(this.manifestPath, snapshot));
+    }
+    migrate(raw) {
+        if (raw?.version === 2 && Array.isArray(raw.sessions))
+            return raw;
+        const sessions = (raw?.sessionHistory ?? []).map((h) => ({
+            sessionId: `legacy-${h.sessionNumber}`,
+            sessionNumber: h.sessionNumber,
+            startedAt: h.startedAt,
+            endedAt: h.endedAt ?? null,
+            lastPersistedAt: h.endedAt ?? null,
+            lastCommittedSequence: 0,
+            status: h.endedAt ? 'COMPLETED' : 'INTERRUPTED',
+        }));
+        return { version: 2, sessions };
+    }
+}
+exports.SessionRegistry = SessionRegistry;

package/dist/core/storage/utility/session-window.d.ts

@@ -0,0 +1,8 @@
+export interface SessionWindow {
+    start: Date;
+    end: Date;
+}
+export declare function getSessionWindow(startedAt: string, endedAt: string | null): SessionWindow;
+export declare function getSessionDatesFromWindow(window: SessionWindow): string[];
+export declare function getSessionHoursFromWindow(window: SessionWindow): string[];
+export declare function hourKeyFor(date: Date | string): string;

package/dist/core/storage/utility/session-window.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSessionWindow = getSessionWindow;
+exports.getSessionDatesFromWindow = getSessionDatesFromWindow;
+exports.getSessionHoursFromWindow = getSessionHoursFromWindow;
+exports.hourKeyFor = hourKeyFor;
+function getSessionWindow(startedAt, endedAt) {
+    return {
+        start: new Date(startedAt),
+        end: endedAt ? new Date(endedAt) : new Date(),
+    };
+}
+function enumerateDates(start, end) {
+    const dates = [];
+    const cursor = new Date(Date.UTC(start.getUTCFullYear(), start.getUTCMonth(), start.getUTCDate()));
+    const last = new Date(Date.UTC(end.getUTCFullYear(), end.getUTCMonth(), end.getUTCDate()));
+    while (cursor <= last) {
+        dates.push(cursor.toISOString().slice(0, 10));
+        cursor.setUTCDate(cursor.getUTCDate() + 1);
+    }
+    return dates;
+}
+function getSessionDatesFromWindow(window) {
+    return enumerateDates(window.start, window.end);
+}
+function enumerateHours(start, end) {
+    const hours = [];
+    const cursor = new Date(Date.UTC(start.getUTCFullYear(), start.getUTCMonth(), start.getUTCDate(), start.getUTCHours()));
+    const last = new Date(Date.UTC(end.getUTCFullYear(), end.getUTCMonth(), end.getUTCDate(), end.getUTCHours()));
+    while (cursor <= last) {
+        hours.push(cursor.toISOString());
+        cursor.setUTCHours(cursor.getUTCHours() + 1);
+    }
+    return hours;
+}
+function getSessionHoursFromWindow(window) {
+    return enumerateHours(window.start, window.end);
+}
+function hourKeyFor(date) {
+    if (typeof date === 'string')
+        date = new Date(date);
+    return new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate(), date.getUTCHours())).toISOString();
+}

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

@@ -0,0 +1,18 @@
+import { type ReadonlyConfig } from "../../config";
+import type { AnalyticsData, AnalyticsFilterSettings } from "../domain";
+import type { TelemetryQueryService } from "./telemetry-query.service";
+export declare class AnalyticsService {
+    private readonly queries;
+    readonly slowLatencyThreshold: number;
+    private readonly viewWindowBuckets;
+    private readonly topImpactRoutes;
+    constructor(queries: TelemetryQueryService, config: ReadonlyConfig);
+    private matchesFilters;
+    private toTelemetry;
+    get(page?: number, pageSize?: number, filters?: AnalyticsFilterSettings | undefined): AnalyticsData;
+    private impactEndpoints;
+    private calculateSummary;
+    private latencyDistribution;
+    private requestVolume;
+    private endpointName;
+}

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

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnalyticsService = void 0;
+const config_1 = require("../../config");
+const bucket_view_1 = require("../storage/stores/bucket-view");
+const utility_1 = require("../utility");
+class AnalyticsService {
+    queries;
+    slowLatencyThreshold;
+    viewWindowBuckets;
+    topImpactRoutes;
+    constructor(queries, config) {
+        this.queries = queries;
+        const dashboard = config.dashboard === false ? config_1.DEFAULT_CONFIG.dashboard : config.dashboard;
+        this.slowLatencyThreshold = config.thresholds.slowLatencyMs;
+        this.viewWindowBuckets = config.cache.viewWindowBuckets;
+        this.topImpactRoutes = dashboard.topImpactRoutes;
+    }
+    matchesFilters(endpoint, filters) {
+        if (!filters)
+            return true;
+        if (filters.method !== 'ALL' && endpoint.method !== filters.method)
+            return false;
+        if (filters.query && !endpoint.route.includes(filters.query))
+            return false;
+        return true;
+    }
+    toTelemetry(derived) {
+        return {
+            method: derived.method,
+            route: derived.route,
+            rps: derived.rps,
+            requestCount: derived.requestCount,
+            averageLatency: derived.averageLatency,
+            minLatency: derived.minLatency,
+            p50: derived.p50,
+            p95: derived.p95,
+            p99: derived.p99,
+            errorRate: derived.errorRate,
+            impactedRequests: derived.impactedRequests,
+            status: derived.status,
+        };
+    }
+    get(page = 1, pageSize = 20, filters = undefined) {
+        const recent = this.queries.recent(this.viewWindowBuckets, { consistency: 'live', includeEndpoints: true });
+        const endpointViews = (0, bucket_view_1.deriveEndpointView)(recent.points, this.slowLatencyThreshold);
+        const endpointList = endpointViews.filter(e => this.matchesFilters(e, filters))
+            .sort((a, b) => a.method.localeCompare(b.method));
+        const telemetryList = endpointList.map(e => this.toTelemetry(e));
+        const pagination = (0, utility_1.paginate)(telemetryList, page, pageSize);
+        return {
+            summary: this.calculateSummary(endpointList),
+            latencyDistribution: this.latencyDistribution(endpointList),
+            requestVolume: this.requestVolume(endpointList),
+            endpointsTable: {
+                data: pagination.data,
+                pagination: pagination.meta,
+            },
+            impactEndpoints: this.impactEndpoints(endpointViews),
+            history: [] // TODO: Remove in future, as history is not currently being used in the analytics dashboard
+        };
+    }
+    impactEndpoints(endpoints) {
+        return endpoints
+            .filter(e => e.impactedRequests > 0)
+            .sort((a, b) => b.impactedRequests - a.impactedRequests || b.requestCount - a.requestCount)
+            .slice(0, this.topImpactRoutes)
+            .map(e => this.toTelemetry(e));
+    }
+    calculateSummary(endpoints) {
+        return {
+            totalEndpoints: endpoints.length,
+            healthyEndpoints: endpoints.filter(e => e.errorRate === 0 && e.p95 < this.slowLatencyThreshold).length,
+            slowEndpoints: endpoints.filter(e => e.p95 >= this.slowLatencyThreshold).length,
+            slowEndpointsThreshold: this.slowLatencyThreshold,
+            errorEndpoints: endpoints.filter(e => e.errorRate > 0).length,
+        };
+    }
+    latencyDistribution(endpoints) {
+        return endpoints.map(endpoint => ({
+            endpoint: this.endpointName(endpoint),
+            p50: endpoint.p50,
+            p95: endpoint.p95,
+            p99: endpoint.p99,
+        }));
+    }
+    requestVolume(endpoints) {
+        return endpoints
+            .map(endpoint => ({
+            endpoint: this.endpointName(endpoint),
+            volume: endpoint.requestCount,
+            rps: endpoint.rps,
+        }))
+            .sort((a, b) => b.volume - a.volume);
+    }
+    endpointName(endpoint) {
+        return `${endpoint.method} ${endpoint.route}`;
+    }
+}
+exports.AnalyticsService = AnalyticsService;

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

@@ -1,18 +1,20 @@
-import type { SystemStaticInfo, AnalyticsData, DashboardData, HealthData } from '../domain';
-import { CPUCollector, MemoryCollector, EventLoopCollector, GCCollector, HandlesCollector, RuntimeCollector } from './collectors';
-declare class CollectorService {
-    private readonly cpuCollector;
-    private readonly memoryCollector;
-    private readonly eventLoopCollector;
-    private readonly gcCollector;
-    private readonly handlesCollector;
-    private readonly runtimeCollector;
-    constructor(cpuCollector: CPUCollector, memoryCollector: MemoryCollector, eventLoopCollector: EventLoopCollector, gcCollector: GCCollector, handlesCollector: HandlesCollector, runtimeCollector: RuntimeCollector);
+import { type SystemStaticInfo, type AnalyticsData, type HealthDetails, type AnalyticsFilterSettings, type BucketsMessage, type BucketsRequest } from '../domain';
+import type { LocalRepository } from "../storage";
+import { type ReadonlyConfig } from '../../config';
+import type { DashboardService } from './dashboard.service';
+import type { AnalyticsService } from './analytics.service';
+import type { RuntimeService } from './runtime.service';
+export declare class CollectorService {
+    private readonly storage;
+    private readonly dashboardService;
+    private readonly analyticsService;
+    private readonly runtimeService;
+    private readonly analyticsPageSize;
+    constructor(storage: LocalRepository, dashboardService: DashboardService, analyticsService: AnalyticsService, runtimeService: RuntimeService, config: ReadonlyConfig);
     getSystemStaticInfo(): SystemStaticInfo;
-    getDashboardData(): DashboardData;
-    getAnalyticsData(): AnalyticsData;
-    getHealthData(): HealthData;
+    getAnalyticsData(filters?: AnalyticsFilterSettings): AnalyticsData;
+    getHealthData(): HealthDetails;
+    getLiveBuckets(): BucketsMessage | null;
+    getBackFill(req: BucketsRequest): Promise<BucketsMessage>;
     tick(): void;
 }
-export declare const collectorService: CollectorService;
-export {};

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

@@ -1,92 +1,35 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.collectorService = void 0;
-const storage_1 = require("../storage");
-const collectors_1 = require("./collectors");
+exports.CollectorService = void 0;
 const config_1 = require("../../config");
 class CollectorService {
-    cpuCollector;
-    memoryCollector;
-    eventLoopCollector;
-    gcCollector;
-    handlesCollector;
-    runtimeCollector;
-    constructor(cpuCollector, memoryCollector, eventLoopCollector, gcCollector, handlesCollector, runtimeCollector) {
-        this.cpuCollector = cpuCollector;
-        this.memoryCollector = memoryCollector;
-        this.eventLoopCollector = eventLoopCollector;
-        this.gcCollector = gcCollector;
-        this.handlesCollector = handlesCollector;
-        this.runtimeCollector = runtimeCollector;
+    storage;
+    dashboardService;
+    analyticsService;
+    runtimeService;
+    analyticsPageSize;
+    constructor(storage, dashboardService, analyticsService, runtimeService, config) {
+        this.storage = storage;
+        this.dashboardService = dashboardService;
+        this.analyticsService = analyticsService;
+        this.runtimeService = runtimeService;
+        this.analyticsPageSize = (config.dashboard === false ? config_1.DEFAULT_CONFIG.dashboard : config.dashboard).analyticsPageSize;
     }
     getSystemStaticInfo() {
-        return storage_1.storage.system.get();
+        return this.runtimeService.getSystemStaticInfo();
     }
-    getDashboardData() {
-        return storage_1.storage.dashboard.get();
-    }
-    getAnalyticsData() {
-        return storage_1.storage.analytics.get();
+    getAnalyticsData(filters) {
+        return this.analyticsService.get(filters?.page || 1, this.analyticsPageSize, filters);
     }
     getHealthData() {
-        return storage_1.storage.health.get();
+        return this.runtimeService.get();
+    }
+    getLiveBuckets() {
+        return this.dashboardService.getLive();
     }
-    tick() {
-        const cpuData = this.cpuCollector.collect();
-        storage_1.storage.health.updateCPU({
-            usageRate: cpuData.totalPercent,
-            numberOfCores: cpuData.numberOfCores,
-            perCoreUsage: cpuData.perCoreUsage,
-            userUsage: cpuData.userPercent,
-            systemUsage: cpuData.systemPercent,
-            idleUsage: cpuData.idlePercent
-        });
-        const memoryData = this.memoryCollector.collect();
-        storage_1.storage.health.updateMemory({
-            heapUsage: memoryData.heapUsage,
-            heapSize: memoryData.heapSize,
-            rssMemory: memoryData.rssMemory,
-            rssMemoryTotal: memoryData.rssMemoryTotal,
-            externalMemory: memoryData.externalMemory,
-        });
-        const eventLoopData = this.eventLoopCollector.collect();
-        storage_1.storage.health.updateEventLoop({
-            lag: eventLoopData.meanMs,
-            threshold: this.eventLoopCollector.thresholdMs,
-        });
-        const handlesData = this.handlesCollector.collect();
-        storage_1.storage.health.updateHandles({
-            activeHandles: handlesData.activeHandles,
-            activeHandlesTimers: handlesData.activeHandlesTimers,
-            activeHandlesSockets: handlesData.activeHandlesSockets,
-            activeLibuvHandles: handlesData.activeLibuvHandles,
-            timers: handlesData.timers,
-            fileDescriptors: handlesData.fileDescriptors
-        });
-        const gcData = this.gcCollector.collect();
-        storage_1.storage.health.updateGC({
-            gcCount: gcData.gcCount,
-            gcTime: gcData.gcTime,
-            gcPauseAverage: gcData.gcPauseAverage,
-            minorGC: gcData.minorGC,
-            majorGC: gcData.majorGC,
-            incrementalGC: gcData.incrementalGC,
-            heapSpaces: gcData.heapSpaces,
-            gcTotals: gcData.gcTotals
-        });
-        const runtimeData = this.runtimeCollector.collect();
-        storage_1.storage.health.updateRuntime({
-            pid: runtimeData.pid,
-            platform: runtimeData.platform,
-            nodeVersion: runtimeData.nodeVersion,
-            v8Version: runtimeData.v8Version,
-            libuvVersion: runtimeData.libuvVersion,
-            openSSLVersion: runtimeData.openSSLVersion,
-            threadPoolSize: runtimeData.threadPoolSize,
-            activeThreads: runtimeData.activeThreads,
-            startup: runtimeData.startup
-        });
-        storage_1.storage.tick();
+    getBackFill(req) {
+        return this.dashboardService.getBackFill(req);
     }
+    tick() { this.storage.tick(); }
 }
-exports.collectorService = new CollectorService(new collectors_1.CPUCollector(), new collectors_1.MemoryCollector(), new collectors_1.EventLoopCollector((0, config_1.getConfig)().publisher.eventLoopResolutionMs, (0, config_1.getConfig)().publisher.eventLoopLagThresholdMs), new collectors_1.GCCollector(), new collectors_1.HandlesCollector(), new collectors_1.RuntimeCollector());
+exports.CollectorService = CollectorService;

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

@@ -1,9 +1,57 @@
-declare class CorrelationService {
-    private readonly sampleSize;
-    constructor();
-    tick(): void;
-    private testCorrelation;
-    private handleReport;
-}
-export declare const correlationService: CorrelationService;
-export {};
+import { SystemAssessment, CorrelationPairResult, type CorrelationData, type RelatedFinding } from '../domain';
+import type { TelemetryQueryService } from './telemetry-query.service';
+import { type ReplayOutcome } from './utility/correlation-replay';
+import { type CorrelationFinding, type CorrelationParameters } from './utility/correlation-finding';
+export interface FindingStore {
+    save(finding: CorrelationFinding): Promise<boolean>;
+    find(findingId: string): Promise<CorrelationFinding | null>;
+    readonly durable: boolean;
+}
+export interface CorrelationDeps {
+    queries: TelemetryQueryService;
+    finding: FindingStore;
+    identity: {
+        sessionId: () => string;
+        instanceId: string;
+    };
+}
+export interface CorrelationServiceOptions {
+    minCorrelation: number;
+    alpha: number;
+    power: number;
+    strongThreshold: number;
+    maxLag: number;
+    maxWindow: number;
+    minCoverage: number;
+    evaluateEveryIntervals: number;
+    analysisIntervalMs: number;
+}
+export declare class CorrelationService {
+    readonly requiredSampleSize: number;
+    readonly parameters: CorrelationParameters;
+    private readonly deps;
+    private readonly transform;
+    private readonly scopes;
+    private readonly analysisIntervalMs;
+    private readonly evaluateEvery;
+    private busy;
+    private lastRunAt;
+    private readonly lastEvaluated;
+    private results;
+    private lowCoverage;
+    private assessment;
+    constructor(deps: CorrelationDeps, options: CorrelationServiceOptions);
+    getResults(): CorrelationPairResult[];
+    getAssessment(): SystemAssessment;
+    pack(): CorrelationData;
+    tick(now?: number): void;
+    private evaluate;
+    private seriesFor;
+    private buildFinding;
+    replay(findingId: string): Promise<ReplayOutcome>;
+    private publish;
+    private toUiResult;
+    private isStrongPositive;
+    private assess;
+    relatedFindings(metric: string): RelatedFinding[];
+}