apm-optima 1.0.5 → 2.0.0

package/dist/core/storage/persistence.layer.js

@@ -0,0 +1,404 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PersistenceRepository = void 0;
+const path_1 = __importDefault(require("path"));
+const promises_1 = __importDefault(require("fs/promises"));
+const crypto_1 = require("crypto");
+const config_1 = require("../../config");
+const utility_1 = require("./utility");
+const persistence_writer_1 = require("./persistence/persistence-writer");
+const session_registry_1 = require("./persistence/session-registry");
+const organizers_1 = require("../organizers");
+const logger_1 = __importDefault(require("../telemetry/logger"));
+const bucket_metric_1 = require("./stores/bucket-metric");
+const segment_index_1 = require("./persistence/segment-index");
+const session_summary_1 = require("./persistence/session-summary");
+class PersistenceRepository {
+    conf;
+    httpBuffer = [];
+    enabled;
+    maxBufferSize;
+    baseDir;
+    persistRawRequests;
+    heartbeatIntervalMs;
+    writer;
+    registry;
+    ready;
+    heartbeatTimer = null;
+    shutdownPromise = null;
+    closing = false;
+    inFlight = new Set();
+    sessionId = (0, crypto_1.randomUUID)();
+    segments;
+    queries = null;
+    constructor(conf) {
+        this.conf = conf;
+        const settings = conf.persistence === false ? config_1.DEFAULT_CONFIG.persistence : conf.persistence;
+        this.enabled = conf.persistence !== false;
+        this.baseDir = settings.baseDir;
+        this.maxBufferSize = settings.maxBufferSize;
+        this.persistRawRequests = settings.persistRawRequests;
+        this.heartbeatIntervalMs = settings.heartbeatIntervalMs;
+        this.writer = new persistence_writer_1.PersistenceWriter({
+            maxQueue: settings.writer.maxQueue,
+            maxRetries: settings.writer.maxRetries,
+            retryDelayMs: settings.writer.retryDelayMs,
+            onStatusChange: (status) => logger_1.default.error(`PersistenceLayer: storage status is now ${status}`)
+        });
+        this.registry = new session_registry_1.SessionRegistry(path_1.default.join(this.baseDir, 'session-manifest.json'), this.writer);
+        this.segments = new segment_index_1.SegmentIndex(this.baseDir);
+        this.ready = this.initSession().catch(err => {
+            logger_1.default.error('Failed to initialize session:', err);
+            return null;
+        });
+    }
+    attachQueryService(q) { this.queries = q; }
+    get isEnabled() { return this.enabled; }
+    get bucketSource() {
+        return { read: (s, f, t, onIssue) => this.readBuckets(s, f, t, onIssue) };
+    }
+    //#region Initialization
+    async initSession() {
+        if (!this.enabled)
+            return null;
+        const removed = await (0, utility_1.cleanupOrphanedTempFiles)(this.baseDir);
+        if (removed > 0) {
+            logger_1.default.debug(`PersistenceLayer: Removed ${removed} orphaned temporary files during initialization.`);
+        }
+        await this.segments.rebuild();
+        const session = await this.registry.start(this.sessionId);
+        logger_1.default.debug(`Session initialized: #${session.sessionNumber} (${session.sessionId}), recoveredFromCrash=${this.registry.recoveredFromCrash}`);
+        if (this.registry.recoveredFromCrash) {
+            void organizers_1.ApplicationEventManager.instance?.emit({
+                type: 'CRASH',
+                reason: 'Application recovered from an unexpected shutdown',
+            });
+        }
+        this.heartbeatTimer = setInterval(() => { void this.registry.heartbeat(); }, this.heartbeatIntervalMs);
+        this.heartbeatTimer.unref();
+        return session;
+    }
+    //#endregion
+    //#region Writing Metrics
+    track(op) {
+        this.inFlight.add(op);
+        void op.finally(() => this.inFlight.delete(op)).catch(() => { });
+        return op;
+    }
+    async drainInFlight() {
+        while (this.inFlight.size > 0) {
+            await Promise.allSettled([...this.inFlight]);
+        }
+    }
+    async enqueue(category, items) {
+        try {
+            await this.writer.enqueueAppend(this.baseDir, category, items);
+            this.registry.notePersisted();
+        }
+        catch {
+            // do nothing
+        }
+    }
+    onHttpRequest(metric) {
+        if (!this.enabled || !this.persistRawRequests || this.closing)
+            return;
+        if (metric.statusCode < 400)
+            return; // Only persisting errors for now
+        this.httpBuffer.push({ recordId: (0, crypto_1.randomUUID)(), payload: metric });
+        if (this.httpBuffer.length >= this.maxBufferSize) {
+            void this.flushHttpBuffer();
+        }
+    }
+    async flushHttpBuffer() {
+        if (!this.enabled || this.httpBuffer.length === 0)
+            return;
+        const batch = this.httpBuffer;
+        this.httpBuffer = [];
+        await this.track(this.enqueue('http_requests', batch));
+    }
+    onBucketClosed(bucket) {
+        if (!this.enabled)
+            return Promise.resolve(false);
+        return this.track((async () => {
+            const session = await this.ready;
+            if (!session)
+                return false;
+            try {
+                await this.writer.enqueueAppend(this.baseDir, 'metric_buckets', [{ recordId: bucket.bucketId, payload: bucket }], { date: new Date(bucket.endTime) });
+                this.segments.noteWritten(bucket);
+                this.registry.notePersisted(bucket.sequence);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        })());
+    }
+    saveCorrelationFinding(finding) {
+        if (!this.enabled)
+            return Promise.resolve(false);
+        return this.track((async () => {
+            const session = await this.ready;
+            if (!session)
+                return false;
+            try {
+                await this.writer.enqueueAppend(this.baseDir, 'correlation', [{ recordId: finding.findingId, payload: finding }]);
+                this.registry.notePersisted();
+                return true;
+            }
+            catch {
+                return false;
+            }
+        })());
+    }
+    onApplicationEvent(event) {
+        if (!this.enabled)
+            return Promise.resolve();
+        const record = { recordId: (0, crypto_1.randomUUID)(), payload: { ...event } };
+        return this.track((async () => {
+            const session = await this.ready;
+            if (!session)
+                return;
+            await this.enqueue('events', [record]);
+        })());
+    }
+    getStorageStatus() {
+        return {
+            status: this.writer.status,
+            lostRecords: this.writer.lostRecords,
+            pending: this.writer.pending + this.inFlight.size,
+            lastError: this.writer.lastError
+        };
+    }
+    //#endregion
+    //#region Reading Metrics
+    async getSessionManifest() {
+        if (!this.enabled)
+            return { version: 2, sessions: [] };
+        await this.ready;
+        return { version: 2, sessions: [...this.registry.all] };
+    }
+    getSessionRecord() {
+        if (!this.enabled) {
+            return {
+                sessionId: 'disabled',
+                sessionNumber: 0,
+                startedAt: new Date().toISOString(),
+                endedAt: null,
+                lastPersistedAt: null,
+                lastCommittedSequence: 0,
+                status: 'RUNNING'
+            };
+        }
+        return this.registry.current;
+    }
+    async findSession(sessionNumber) {
+        await this.ready;
+        return this.registry.all.find(s => s.sessionNumber === sessionNumber) ?? null;
+    }
+    async resolveExistingFile(category, date) {
+        const dir = path_1.default.join(this.baseDir, category);
+        const plain = path_1.default.join(dir, `${date}.ndjson`);
+        const gz = `${plain}.gz`;
+        if (await promises_1.default.access(plain).then(() => true).catch(() => false))
+            return plain;
+        if (await promises_1.default.access(gz).then(() => true).catch(() => false))
+            return gz;
+        return null;
+    }
+    requireQueries() {
+        if (!this.queries)
+            throw new Error('PersistenceRepository: query service not attached');
+        return this.queries;
+    }
+    sessionQuery(session) {
+        const window = session_registry_1.SessionRegistry.window(session);
+        return {
+            sessionId: session.sessionId,
+            from: window.start.toISOString(),
+            to: window.end.toISOString(),
+            consistency: session.status === 'RUNNING' ? 'live' : 'committed',
+        };
+    }
+    async getSessionSummary(sessionNumber) {
+        const session = await this.findSession(sessionNumber);
+        if (!session)
+            return null;
+        const incidents = await this.sessionIncidents(session);
+        const dashboard = this.conf.dashboard === false ? config_1.DEFAULT_CONFIG.dashboard : this.conf.dashboard;
+        return (0, session_summary_1.buildSessionSummary)(this.requireQueries(), session, dashboard.sessionSummaryWindowHours, this.conf.thresholds.slowLatencyMs, incidents);
+    }
+    async sessionIncidents(session) {
+        if (!this.enabled)
+            return [];
+        const byId = new Map();
+        const events = this.sessionRecords('events', session, e => (e.type === 'INCIDENT_OPENED' || e.type === 'INCIDENT_RESOLVED')
+            && e.details?.sessionId === session.sessionId);
+        for await (const event of events) {
+            const incident = event.details;
+            const prev = byId.get(incident.incidentId);
+            if (!prev || prev.status !== 'RESOLVED')
+                byId.set(incident.incidentId, incident);
+        }
+        return [...byId.values()].sort((a, b) => b.firedAt.localeCompare(a.firedAt));
+    }
+    async findCorrelationFinding(findingId) {
+        if (!this.enabled)
+            return null;
+        await this.ready;
+        const sessionId = findingId.split(':')[0];
+        const session = this.registry.all.find(s => s.sessionId === sessionId);
+        if (!session)
+            return null;
+        for (const date of session_registry_1.SessionRegistry.enumerateDates(session_registry_1.SessionRegistry.window(session))) {
+            const file = await this.resolveExistingFile('correlation', date);
+            if (!file)
+                continue;
+            for await (const rec of (0, persistence_writer_1.dedupeRecords)((0, utility_1.readRecords)(file))) {
+                if (rec.id === findingId)
+                    return rec.payload;
+            }
+        }
+        return null;
+    }
+    async *readBuckets(sessionId, fromMs, toMs, onIssue) {
+        for (const date of this.segments.find(sessionId, fromMs, toMs)) {
+            const file = await this.resolveExistingFile('metric_buckets', date);
+            if (!file) {
+                onIssue({ type: 'SOURCE_ERROR', detail: `Missing segment ${date}` });
+                continue;
+            }
+            const records = (0, persistence_writer_1.dedupeRecords)((0, utility_1.readRecords)(file), id => onIssue({ type: 'CONFLICT', bucketId: id }));
+            for await (const rec of records) {
+                const b = rec.payload;
+                if (b?.schemaVersion !== bucket_metric_1.BUCKET_SCHEMA_VERSION || b.sessionId !== sessionId)
+                    continue;
+                if (Date.parse(b.startTime) > toMs || Date.parse(b.endTime) < fromMs)
+                    continue;
+                yield b;
+            }
+        }
+    }
+    //#endregion
+    //#region Shutdown
+    async shutdown() {
+        if (!this.enabled)
+            return;
+        if (this.shutdownPromise)
+            return this.shutdownPromise;
+        this.shutdownPromise = (async () => {
+            logger_1.default.debug('PersistenceLayer: Shutdown initiated.');
+            this.closing = true;
+            if (this.heartbeatTimer)
+                clearInterval(this.heartbeatTimer);
+            try {
+                await this.ready;
+                await this.flushHttpBuffer();
+                await this.drainInFlight();
+                await this.writer.whenIdle();
+                await this.segments.persistClosed();
+                await this.registry.complete();
+                await this.writer.close();
+                const removed = await (0, utility_1.cleanupOrphanedTempFiles)(this.baseDir);
+                if (removed > 0) {
+                    logger_1.default.debug(`PersistenceLayer: Removed ${removed} orphaned temporary files during shutdown.`);
+                }
+                logger_1.default.debug(`PersistenceLayer: Shutdown complete (lostRecords=${this.writer.lostRecords}).`);
+            }
+            catch (err) {
+                logger_1.default.error("Error during persistence shutdown:", err);
+            }
+        })();
+        return this.shutdownPromise;
+    }
+    //#endregion
+    //#region Archiving
+    async archiveOldCategory(category) {
+        const dir = path_1.default.join(this.baseDir, category);
+        const today = new Date().toISOString().slice(0, 10);
+        const files = await promises_1.default.readdir(dir).catch(() => []);
+        for (const file of files) {
+            if (!file.endsWith('.ndjson'))
+                continue;
+            if (file.startsWith(today))
+                continue;
+            const fullPath = path_1.default.join(dir, file);
+            await (0, utility_1.writeChecksum)(fullPath);
+            await (0, utility_1.archiveFile)(fullPath);
+        }
+    }
+    archiveAllCategories() {
+        const categories = ['http_requests', 'events', 'correlation', 'metric_buckets'];
+        for (const category of categories) {
+            this.archiveOldCategory(category).catch(err => {
+                logger_1.default.error(`Error archiving old ${category} files`, err);
+            });
+        }
+        void this.segments.persistClosed();
+    }
+    //#endregion
+    //#region Session Export
+    async writeChunk(out, chunk) {
+        if (!out.write(chunk))
+            await new Promise(resolve => out.once('drain', resolve));
+    }
+    async streamJsonArray(out, name, items, last = false) {
+        await this.writeChunk(out, `${JSON.stringify(name)}:[`);
+        let first = true;
+        for await (const item of items) {
+            await this.writeChunk(out, (first ? '' : ',') + JSON.stringify(item));
+            first = false;
+        }
+        await this.writeChunk(out, last ? ']' : '],');
+    }
+    async *sessionRecords(category, session, belongs) {
+        const window = session_registry_1.SessionRegistry.window(session);
+        for (const date of session_registry_1.SessionRegistry.enumerateDates(window)) {
+            const file = await this.resolveExistingFile(category, date);
+            if (!file)
+                continue;
+            for await (const rec of (0, persistence_writer_1.dedupeRecords)((0, utility_1.readRecords)(file))) {
+                if (belongs(rec.payload))
+                    yield rec.payload;
+            }
+        }
+    }
+    async streamSessionExport(out, sessionNumber) {
+        const session = await this.findSession(sessionNumber);
+        if (!session)
+            return false;
+        const queries = this.requireQueries();
+        const window = session_registry_1.SessionRegistry.window(session);
+        const inWindow = (iso) => {
+            const t = iso ? Date.parse(iso) : NaN;
+            return t >= window.start.getTime() && t <= window.end.getTime();
+        };
+        const incidents = await this.sessionIncidents(session);
+        const summary = await (0, session_summary_1.buildSessionSummary)(queries, session, Number.POSITIVE_INFINITY, this.conf.thresholds.slowLatencyMs, incidents);
+        const issues = [];
+        const query = this.sessionQuery(session);
+        const buckets = (async function* () {
+            for await (const e of queries.buckets(query, i => issues.push(i)))
+                yield e.bucket;
+        })();
+        await this.writeChunk(out, '{');
+        await this.writeChunk(out, `"sessionId":${JSON.stringify(session.sessionId)},`);
+        await this.writeChunk(out, `"sessionNumber":${JSON.stringify(session.sessionNumber)},`);
+        await this.writeChunk(out, `"status":${JSON.stringify(session.status)},`);
+        await this.writeChunk(out, `"startedAt":${JSON.stringify(session.startedAt)},`);
+        await this.writeChunk(out, `"endedAt":${JSON.stringify(session.endedAt)},`);
+        await this.writeChunk(out, `"lastCommittedSequence":${JSON.stringify(session.lastCommittedSequence)},`);
+        await this.writeChunk(out, `"summary":${JSON.stringify(summary)},`);
+        await this.streamJsonArray(out, 'metric_buckets', buckets);
+        await this.writeChunk(out, `"bucketIssues":${JSON.stringify(issues)},`);
+        await this.streamJsonArray(out, 'events', this.sessionRecords('events', session, e => inWindow(e.timestamp)));
+        await this.streamJsonArray(out, 'http_requests', this.sessionRecords('http_requests', session, r => inWindow(r.timestamp)));
+        await this.streamJsonArray(out, 'correlation', this.sessionRecords('correlation', session, f => f.sessionId === session.sessionId), true);
+        await this.writeChunk(out, '}');
+        return true;
+    }
+}
+exports.PersistenceRepository = PersistenceRepository;

package/dist/core/storage/runtime/anomaly-detector.d.ts

@@ -0,0 +1,11 @@
+export declare class AnomalyDetector {
+    private readonly minSamples;
+    private readonly lowerLimitMs;
+    private readonly zThreshold;
+    private readonly windowCap;
+    private n;
+    private mean;
+    private m2;
+    constructor(minSamples?: number, lowerLimitMs?: number, zThreshold?: number, windowCap?: number);
+    record(duration: number): boolean;
+}

package/dist/core/storage/runtime/anomaly-detector.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnomalyDetector = void 0;
+class AnomalyDetector {
+    minSamples;
+    lowerLimitMs;
+    zThreshold;
+    windowCap;
+    n = 0;
+    mean = 0;
+    m2 = 0;
+    constructor(minSamples = 60, lowerLimitMs = 180, zThreshold = 3, windowCap = 5000) {
+        this.minSamples = minSamples;
+        this.lowerLimitMs = lowerLimitMs;
+        this.zThreshold = zThreshold;
+        this.windowCap = windowCap;
+    }
+    record(duration) {
+        if (!Number.isFinite(duration))
+            return false;
+        let anomalyDetected = false;
+        if (this.n >= this.minSamples && duration >= this.lowerLimitMs) {
+            const std = Math.sqrt(this.m2 / (this.n - 1));
+            anomalyDetected = std > 0 ? (duration - this.mean) / std > this.zThreshold : duration > this.mean;
+        }
+        if (this.n < this.windowCap) {
+            this.n++;
+            const delta = duration - this.mean;
+            this.mean += delta / this.n;
+            this.m2 += delta * (duration - this.mean);
+        }
+        else {
+            const alpha = 1 / this.windowCap;
+            const delta = duration - this.mean;
+            const variance = (this.m2 / (this.n - 1) + alpha * delta * delta) * (1 - alpha);
+            this.mean += alpha * delta;
+            this.m2 = variance * (this.n - 1);
+        }
+        return anomalyDetected;
+    }
+}
+exports.AnomalyDetector = AnomalyDetector;

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

@@ -1,12 +1,12 @@
-import type { AnalyticsData } from "../../domain";
-import { EndpointStore } from "./endpoint.store";
+import type { AnalyticsData, AnalyticsFilterSettings } from "../../domain";
 import type { BucketStore } from "./bucket.store";
 declare class AnalyticsStore {
     private readonly buckets;
-    private readonly endpoints;
     private readonly slowLatencyThreshold;
-    constructor(buckets: BucketStore, endpoints: EndpointStore, slowLatencyThreshold?: number);
-    get(page?: number, pageSize?: number): AnalyticsData;
+    constructor(buckets: BucketStore, slowLatencyThreshold?: number);
+    private matchesFilters;
+    private toTelemetry;
+    get(page?: number, pageSize?: number, filters?: AnalyticsFilterSettings | undefined): AnalyticsData;
     private calculateSummary;
     private latencyDistribution;
     private requestVolume;

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

@@ -2,18 +2,45 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AnalyticsStore = void 0;
 const utility_1 = require("../../utility");
+const bucket_view_1 = require("./bucket-view");
+const bucket_metric_1 = require("./bucket-metric");
 class AnalyticsStore {
     buckets;
-    endpoints;
     slowLatencyThreshold;
-    constructor(buckets, endpoints, slowLatencyThreshold = 500) {
+    constructor(buckets, slowLatencyThreshold = 500) {
         this.buckets = buckets;
-        this.endpoints = endpoints;
         this.slowLatencyThreshold = slowLatencyThreshold;
     }
-    get(page = 1, pageSize = 20) {
+    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;
+        //! REMOVE STATUS FILTERING FOR NOW
+        return true;
+    }
+    toTelemetry(endpoint, durationMs) {
+        const metrics = (0, bucket_metric_1.deriveMetrics)(endpoint, durationMs);
+        return {
+            method: endpoint.method,
+            route: endpoint.route,
+            rps: metrics.rps,
+            requestCount: metrics.requestCount,
+            averageLatency: metrics.averageLatency,
+            minLatency: metrics.minLatency,
+            p95: metrics.p95,
+            p99: metrics.p99,
+            errorRate: metrics.errorRate,
+            status: metrics.errorRate > 0 ? 'DEGRADED' : 'HEALTHY',
+        };
+    }
+    get(page = 1, pageSize = 20, filters = undefined) {
         const history = this.buckets.getHistory();
-        const endpointList = this.endpoints.all();
+        const endpointViews = (0, bucket_view_1.deriveEndpointView)(history);
+        const endpointList = endpointViews.filter(e => this.matchesFilters(e, filters))
+            .sort((a, b) => a.method.localeCompare(b.method));
         const pagination = (0, utility_1.paginate)(endpointList, page, pageSize);
         return {
             summary: this.calculateSummary(endpointList),
@@ -23,14 +50,14 @@ class AnalyticsStore {
                 data: pagination.data,
                 pagination: pagination.meta,
             },
-            history: history.map(bucket => bucket.endpoints),
+            history: history.map(bucket => bucket.endpoints.map(endpoint => this.toTelemetry(endpoint, bucket.durationMs))) //! FIX HISTORY 
         };
     }
     calculateSummary(endpoints) {
         return {
             totalEndpoints: endpoints.length,
-            healthyEndpoints: endpoints.filter(e => e.errorRate === 0 && (e.p95 ?? 0) < this.slowLatencyThreshold).length,
-            slowEndpoints: endpoints.filter(e => (e.p95 ?? 0) >= this.slowLatencyThreshold).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,
         };
@@ -38,16 +65,16 @@ class AnalyticsStore {
     latencyDistribution(endpoints) {
         return endpoints.map(endpoint => ({
             endpoint: this.endpointName(endpoint),
-            p50: endpoint.averageLatency ?? 0,
-            p95: endpoint.p95 ?? 0,
-            p99: endpoint.p99 ?? 0,
+            p50: endpoint.p50,
+            p95: endpoint.p95,
+            p99: endpoint.p99,
         }));
     }
     requestVolume(endpoints) {
         return endpoints
             .map(endpoint => ({
             endpoint: this.endpointName(endpoint),
-            volume: endpoint.requestCount ?? 0,
+            volume: endpoint.requestCount,
             rps: endpoint.rps,
         }))
             .sort((a, b) => b.volume - a.volume);

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

@@ -0,0 +1,85 @@
+export type Origin = 'real' | 'synthetic';
+export type RequestAggregate = {
+    requestCount: number;
+    clientErrorCount: number;
+    serverErrorCount: number;
+    durationSumMs: number;
+    durationMaxMs: number | null;
+    durationMinMs: number | null;
+    histogramSchemaId: string;
+    histogramCounts: number[];
+};
+export type RuntimeInterval = {
+    cpuTimeUs: number | null;
+    cpuUserUs: number | null;
+    cpuSystemUs: number | null;
+    heapUsedBytes: number | null;
+    heapTotalBytes: number | null;
+    heapLimitBytes: number | null;
+    rssBytes: number | null;
+    eventLoopSampleCount: number;
+    eventLoopDelaySumMs: number | null;
+    eventLoopDelayMaxMs: number | null;
+    gcCount: number | null;
+    gcDurationSumMs: number | null;
+};
+export type EndpointAggregate = RequestAggregate & {
+    method: string;
+    route: string;
+};
+export type MetricBucket = {
+    schemaVersion: typeof BUCKET_SCHEMA_VERSION;
+    bucketId: string;
+    sessionId: string;
+    instanceId: string;
+    sequence: number;
+    startTime: string;
+    endTime: string;
+    durationMs: number;
+    origin: Origin;
+    requests: RequestAggregate;
+    endpoints: EndpointAggregate[];
+    runtime: RuntimeInterval;
+    qualityFlags: string[];
+};
+export declare const BUCKET_SCHEMA_VERSION: 3;
+export declare const HISTOGRAM_SCHEMA_ID = "lat-v1";
+export declare const HISTOGRAM_UPPER_BOUNDS_MS: readonly number[];
+export declare const HISTOGRAM_BUCKET_COUNT: number;
+export declare function createAggregate(): RequestAggregate;
+export declare function histogramIndex(duration: number): number;
+export declare function recordInto(agg: RequestAggregate, durationMs: number, statusCode: number): boolean;
+export declare function mergeInto(t: RequestAggregate, s: RequestAggregate): void;
+export declare function mergeAggregates(a: RequestAggregate, b: RequestAggregate): RequestAggregate;
+export declare function percentileFromAggregate(agg: RequestAggregate, q: number): number;
+export declare function countSlowerThan(agg: RequestAggregate, thresholdMs: number): number;
+export declare function deriveMetrics(agg: RequestAggregate, durationMs: number): {
+    requestCount: number;
+    rps: number;
+    averageLatency: number;
+    minLatency: number;
+    maxLatency: number;
+    p50: number;
+    p95: number;
+    p99: number;
+    errorRate: number;
+    clientErrorCount: number;
+    serverErrorCount: number;
+};
+export declare function emptyRuntime(): RuntimeInterval;
+export declare function mergeRuntimeInto(t: RuntimeInterval, s: RuntimeInterval, sIsLater: boolean): void;
+export declare function deriveRuntime(rt: RuntimeInterval, durationMs: number): {
+    cpuPercent: number | null;
+    cpuUserPercent: number | null;
+    cpuSystemPercent: number | null;
+    eventLoopDelayMeanMs: number | null;
+    eventLoopDelayMaxMs: number | null;
+    gcCount: number | null;
+    gcDurationSumMs: number | null;
+    gcPauseAverageMs: number | null;
+    heapUsedBytes: number | null;
+    heapTotalBytes: number | null;
+    heapLimitBytes: number | null;
+    rssBytes: number | null;
+};
+export declare function deepFreeze<T>(v: T): T;