apm-optima 1.0.5 → 2.0.0

package/dist/core/delivery/metrics.publisher.js

@@ -4,33 +4,33 @@ exports.MetricsPublisher = void 0;
 const websocket_events_1 = require("./websocket.events");
 class MetricsPublisher {
     provider;
+    sessionProvider;
+    correlationProvider;
+    incidentProvider;
     websocket;
-    intervalMs;
-    interval;
-    constructor(provider, websocket, intervalMs = 1000) {
+    publishData = null;
+    constructor(provider, sessionProvider, correlationProvider, incidentProvider, websocket) {
         this.provider = provider;
+        this.sessionProvider = sessionProvider;
+        this.correlationProvider = correlationProvider;
+        this.incidentProvider = incidentProvider;
         this.websocket = websocket;
-        this.intervalMs = intervalMs;
-    }
-    start() {
-        if (this.interval)
-            return;
-        this.interval = setInterval(() => {
-            this.publish();
-        }, this.intervalMs);
-    }
-    stop() {
-        if (!this.interval)
-            return;
-        clearInterval(this.interval);
-        this.interval = undefined;
     }
     publish() {
-        //? consider sending only the changed data instead of sending all data every time
-        this.websocket.broadcast(websocket_events_1.WebSocketEvents.RESPONSE_SYSTEM_DATA, this.provider.getSystemStaticInfo());
-        this.websocket.broadcast(websocket_events_1.WebSocketEvents.RESPONSE_DASHBOARD_DATA, this.provider.getDashboardData());
-        this.websocket.broadcast(websocket_events_1.WebSocketEvents.RESPONSE_ANALYTICS_DATA, this.provider.getAnalyticsData());
-        this.websocket.broadcast(websocket_events_1.WebSocketEvents.RESPONSE_HEALTH_DATA, this.provider.getHealthData());
+        this.publishData = {
+            systemStaticInfo: this.provider.getSystemStaticInfo(),
+            analyticsData: this.provider.getAnalyticsData(),
+            healthData: this.provider.getHealthData(),
+            correlationData: this.correlationProvider.pack(),
+        };
+        this.websocket.broadcast(websocket_events_1.WebSocketEvents.RESPONSE_SYSTEM_DATA, this.publishData.systemStaticInfo);
+        this.websocket.broadcast(websocket_events_1.WebSocketEvents.RESPONSE_ANALYTICS_DATA, this.publishData.analyticsData);
+        this.websocket.broadcast(websocket_events_1.WebSocketEvents.RESPONSE_HEALTH_DATA, this.publishData.healthData);
+        this.websocket.broadcast(websocket_events_1.WebSocketEvents.RESPONSE_CORRELATION_DATA, this.publishData.correlationData);
+        this.websocket.broadcast(websocket_events_1.WebSocketEvents.RESPONSE_INCIDENTS, this.incidentProvider.snapshot());
+        const live = this.provider.getLiveBuckets();
+        if (live)
+            this.websocket.broadcast(websocket_events_1.WebSocketEvents.RESPONSE_DASHBOARD_BUCKETS, live);
     }
 }
 exports.MetricsPublisher = MetricsPublisher;

package/dist/core/delivery/websocket.events.d.ts

@@ -1,12 +1,23 @@
 export declare enum WebSocketEvents {
+    REQUEST_SESSION_METADATA = "request-session-metadata",
+    RESPONSE_SESSION_METADATA = "response-session-metadata",
+    REQUEST_SESSION_SUMMARY = "request-session-summary",
+    RESPONSE_SESSION_SUMMARY = "response-session-summary",
     REQUEST_CONFIGURATION = "request-configuration",
     RESPONSE_CONFIGURATION = "response-configuration",
     REQUEST_SYSTEM_DATA = "request-system-data",
     RESPONSE_SYSTEM_DATA = "response-system-data",
-    REQUEST_DASHBOARD_DATA = "request-dashboard-data",
-    RESPONSE_DASHBOARD_DATA = "response-dashboard-data",
     REQUEST_ANALYTICS_DATA = "request-analytics-data",
     RESPONSE_ANALYTICS_DATA = "response-analytics-data",
+    RESPONSE_FILTERED_ANALYTICS_DATA = "response-filtered-analytics-data",
     REQUEST_HEALTH_DATA = "request-health-data",
-    RESPONSE_HEALTH_DATA = "response-health-data"
+    RESPONSE_HEALTH_DATA = "response-health-data",
+    REQUEST_CORRELATION_DATA = "request-correlation-data",
+    RESPONSE_CORRELATION_DATA = "response-correlation-data",
+    REQUEST_CORRELATION_REPLAY = "request-correlation-replay",
+    RESPONSE_CORRELATION_REPLAY = "response-correlation-replay",
+    REQUEST_INCIDENTS = "request-incidents",
+    RESPONSE_INCIDENTS = "response-incidents",
+    REQUEST_DASHBOARD_BUCKETS = "request-dashboard-buckets",
+    RESPONSE_DASHBOARD_BUCKETS = "response-dashboard-buckets"
 }

package/dist/core/delivery/websocket.events.js

@@ -3,14 +3,25 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.WebSocketEvents = void 0;
 var WebSocketEvents;
 (function (WebSocketEvents) {
+    WebSocketEvents["REQUEST_SESSION_METADATA"] = "request-session-metadata";
+    WebSocketEvents["RESPONSE_SESSION_METADATA"] = "response-session-metadata";
+    WebSocketEvents["REQUEST_SESSION_SUMMARY"] = "request-session-summary";
+    WebSocketEvents["RESPONSE_SESSION_SUMMARY"] = "response-session-summary";
     WebSocketEvents["REQUEST_CONFIGURATION"] = "request-configuration";
     WebSocketEvents["RESPONSE_CONFIGURATION"] = "response-configuration";
     WebSocketEvents["REQUEST_SYSTEM_DATA"] = "request-system-data";
     WebSocketEvents["RESPONSE_SYSTEM_DATA"] = "response-system-data";
-    WebSocketEvents["REQUEST_DASHBOARD_DATA"] = "request-dashboard-data";
-    WebSocketEvents["RESPONSE_DASHBOARD_DATA"] = "response-dashboard-data";
     WebSocketEvents["REQUEST_ANALYTICS_DATA"] = "request-analytics-data";
     WebSocketEvents["RESPONSE_ANALYTICS_DATA"] = "response-analytics-data";
+    WebSocketEvents["RESPONSE_FILTERED_ANALYTICS_DATA"] = "response-filtered-analytics-data";
     WebSocketEvents["REQUEST_HEALTH_DATA"] = "request-health-data";
     WebSocketEvents["RESPONSE_HEALTH_DATA"] = "response-health-data";
+    WebSocketEvents["REQUEST_CORRELATION_DATA"] = "request-correlation-data";
+    WebSocketEvents["RESPONSE_CORRELATION_DATA"] = "response-correlation-data";
+    WebSocketEvents["REQUEST_CORRELATION_REPLAY"] = "request-correlation-replay";
+    WebSocketEvents["RESPONSE_CORRELATION_REPLAY"] = "response-correlation-replay";
+    WebSocketEvents["REQUEST_INCIDENTS"] = "request-incidents";
+    WebSocketEvents["RESPONSE_INCIDENTS"] = "response-incidents";
+    WebSocketEvents["REQUEST_DASHBOARD_BUCKETS"] = "request-dashboard-buckets";
+    WebSocketEvents["RESPONSE_DASHBOARD_BUCKETS"] = "response-dashboard-buckets";
 })(WebSocketEvents || (exports.WebSocketEvents = WebSocketEvents = {}));

package/dist/core/domain/correlation.types.d.ts

@@ -0,0 +1,37 @@
+export interface SystemAssessment {
+    status: 'INSUFFICIENT_DATA' | 'NO_SATURATION_PATTERN' | 'POSSIBLE_SATURATION';
+    evidence: string[];
+    recommendation: string;
+}
+export type CorrelationStatus = 'INSUFFICIENT_DATA' | 'NO_STRONG_ASSOCIATION' | 'STRONG_LINEAR_ASSOCIATION' | 'STRONG_MONOTONIC_NONLINEAR_ASSOCIATION';
+export type CorrelationDirection = 'POSITIVE' | 'NEGATIVE' | 'NONE';
+export interface CorrelationAnalysis {
+    status: CorrelationStatus;
+    direction: CorrelationDirection;
+    pearsonR: number;
+    spearmanR: number;
+    rawPearsonR: number;
+    differencePearsonR: number;
+    determination: number;
+    lag: number;
+    laggedPearsonR: number;
+    sampleSize: number;
+    effectiveSampleSize: number;
+    requiredSampleSize: number;
+    autocorrelationX: number;
+    autocorrelationY: number;
+    trendDriven: boolean;
+    recommendation: string;
+}
+export interface CorrelationPairResult {
+    id: string;
+    xLabel: string;
+    yLabel: string;
+    expectedDirection: Exclude<CorrelationDirection, 'NONE'>;
+    unexpectedDirection: boolean;
+    analysis: CorrelationAnalysis;
+}
+export interface CorrelationData {
+    results: CorrelationPairResult[];
+    assessment: SystemAssessment;
+}

package/dist/core/domain/correlation.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/domain/dashboard.types.d.ts

@@ -1,49 +1,17 @@
-import type { AlertMessage, PaginationMeta } from './common.types';
-import type { CpuMetrics, MemoryMetrics, EventLoopMetrics, GCMetrics, LibuvHandles, HistoricTimeSeries } from './metrics.types';
+import type { PaginationMeta } from './common.types';
+import type { CpuMetrics, MemoryMetrics, EventLoopMetrics, GCMetrics, LibuvHandles } from './metrics.types';
 import type { V8RuntimeInfo } from './system.types';
 import type { EndpointTelemetry, EndpointLatencyDistribution, EndpointVolume } from './endpoints.types';
 /**
- * Represents the complete dashboard data structure, including current metrics, historical data, impacted endpoints, alerts, and chart configurations.
- * @property {object} current - Current instantaneous values for various metrics.
- * @property {HistoricTimeSeries} history - Historical time series data for various metrics.
- * @property {EndpointTelemetry[]} impactEndpoints - List of impacted endpoints with their telemetry data.
- * @property {AlertMessage[]} alerts - List of alert messages.
- * @property {object} charts - Explicit chart configuration maps matching chart configurations directly.
- * @property {object} charts.throughputAndLatency - Chart data for throughput and latency metrics.
- * @property {object} charts.runtimePerformance - Chart data for runtime performance metrics.
+ * Represents the analytics filter settings used for filtering analytics data based on query, HTTP method, and status code.
+ * @property {string} query - The search query string for filtering analytics data.
+ * @property {'ALL' | 'GET' | 'POST' | 'PUT' | 'DELETE'} method - The HTTP method filter for analytics data.
+ * @property {number} page - The page number for paginated analytics data.
  */
-export interface DashboardData {
-    current: {
-        rps: number;
-        latency: number;
-        errorRate: number;
-        eventLoopLag: number;
-        heapUsage: number;
-        heapSize: number;
-    };
-    history: HistoricTimeSeries;
-    impactEndpoints: EndpointTelemetry[];
-    alerts: AlertMessage[];
-    charts: {
-        throughput: {
-            rps: number[];
-            errorClient: number[];
-            errorServer: number[];
-            totalCount: number;
-        };
-        percentiles: {
-            p50: number[];
-            p95: number[];
-            p99: number[];
-            totalCount: number;
-        };
-        runtimePerformance: {
-            heapUsage: number[];
-            heapSize: number[];
-            lag: number[];
-            totalCount: number;
-        };
-    };
+export interface AnalyticsFilterSettings {
+    query: string;
+    method: 'ALL' | 'GET' | 'POST' | 'PUT' | 'DELETE';
+    page: number;
 }
 /**
  * Represents the analytics data structure, including summary statistics, latency distribution, request volume, and a paginated table of endpoint telemetry data.
@@ -74,35 +42,14 @@ export interface AnalyticsData {
         pagination: PaginationMeta;
     };
     history: EndpointTelemetry[][];
+    impactEndpoints: EndpointTelemetry[];
 }
-/**
- * Represents the health data structure, including CPU metrics, memory metrics, event loop metrics, libuv handle metrics, garbage collection metrics, V8 runtime information, and historical data for event loop lag and memory breakdown.
- * @property {CpuMetrics} cpu - CPU metrics data.
- * @property {MemoryMetrics} memory - Memory metrics data.
- * @property {EventLoopMetrics} eventLoop - Event loop metrics data.
- * @property {LibuvHandles} handles - Libuv handle metrics data.
- * @property {GCMetrics} garbageCollection - Garbage collection metrics data.
- * @property {V8RuntimeInfo} runtime - V8 runtime information data.
- * @property {object} history - Historical data for event loop lag and memory breakdown.
- * @property {number[]} history.eventLoopLag - Array of historical event loop lag values.
- * @property {object} history.memoryBreakdown - Historical memory breakdown data.
- * @property {number[]} history.memoryBreakdown.usedHeap - Array of historical used heap memory values.
- * @property {number[]} history.memoryBreakdown.totalHeap - Array of historical total heap memory values.
- * @property {number[]} history.memoryBreakdown.rssMemory - Array of historical resident set size (RSS) memory values.
- */
-export interface HealthData {
-    cpu: CpuMetrics;
-    memory: MemoryMetrics;
-    eventLoop: EventLoopMetrics;
+export interface HealthDetails {
+    cpu: Pick<CpuMetrics, 'numberOfCores' | 'perCoreUsage'>;
+    memory: Pick<MemoryMetrics, 'rssMemoryTotal' | 'externalMemory'>;
+    eventLoop: Pick<EventLoopMetrics, 'threshold'>;
     handles: LibuvHandles;
     garbageCollection: GCMetrics;
     runtime: V8RuntimeInfo;
-    history: {
-        eventLoopLag: number[];
-        memoryBreakdown: {
-            usedHeap: number[];
-            totalHeap: number[];
-            rssMemory: number[];
-        };
-    };
 }
+export declare const emptyHealthDetails: () => HealthDetails;

package/dist/core/domain/dashboard.types.js

@@ -1,2 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.emptyHealthDetails = void 0;
+const emptyHealthDetails = () => ({
+    cpu: { numberOfCores: 0, perCoreUsage: [] },
+    memory: { rssMemoryTotal: 0, externalMemory: 0 },
+    eventLoop: { threshold: 0 },
+    handles: { activeHandles: 0, activeHandlesTimers: 0, activeHandlesSockets: 0, activeLibuvHandles: 0, timers: 0, fileDescriptors: 0 },
+    garbageCollection: {
+        gcCount: 0,
+        gcTime: 0,
+        gcPauseAverage: 0,
+        minorGC: { runCount: 0, averageTime: 0 },
+        majorGC: { runCount: 0, averageTime: 0 },
+        incrementalGC: { runCount: 0, averageTime: 0 },
+        heapSpaces: [],
+        gcTotals: { totalPauseTime: 0, freedMemory: 0, promotions: 0, tenuredSize: 0 }
+    },
+    runtime: {
+        pid: 0,
+        platform: '',
+        nodeVersion: '',
+        v8Version: '',
+        libuvVersion: '',
+        openSSLVersion: '',
+        threadPoolSize: 0,
+        activeThreads: 0,
+        startup: { bootstrapTime: 0, requiredModules: 0 }
+    }
+});
+exports.emptyHealthDetails = emptyHealthDetails;

package/dist/core/domain/endpoints.types.d.ts

@@ -11,12 +11,15 @@ import type { EndpointRoute } from './common.types';
  */
 export interface EndpointTelemetry extends EndpointRoute {
     rps: number;
+    p50: number;
     p95: number;
     p99?: number;
     errorRate: number;
     status?: string;
     requestCount?: number;
     averageLatency?: number;
+    minLatency?: number;
+    impactedRequests?: number;
 }
 /**
  * Represents the latency distribution for a specific endpoint, including the 50th, 95th, and 99th percentile latencies.

package/dist/core/domain/event.types.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Represents the types of events that can occur in the application.
+ */
+export type ApplicationEventType = 'STARTUP' | 'SHUTDOWN' | 'CRASH' | 'INCIDENT_OPENED' | 'INCIDENT_RESOLVED';
+/**
+ * Represents an event that occurs in the application.
+ */
+export interface ApplicationEvent {
+    timestamp: string;
+    type: ApplicationEventType;
+    applicationVersion: string;
+    reason: string;
+    details?: Record<string, unknown>;
+}

package/dist/core/domain/event.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/domain/incident.types.d.ts

@@ -0,0 +1,50 @@
+export type IncidentState = 'NORMAL' | 'PENDING' | 'FIRING' | 'RESOLVED';
+export type IncidentSeverity = 'warning' | 'critical';
+export interface RelatedFinding {
+    findingId: string;
+    pairId: string;
+    status: string;
+    direction: string;
+    pearsonR: number;
+}
+export interface Incident {
+    incidentId: string;
+    sessionId: string;
+    ruleId: string;
+    title: string;
+    metric: string;
+    unit: string;
+    severity: IncidentSeverity;
+    status: 'FIRING' | 'RESOLVED';
+    threshold: number;
+    recoverBelow: number;
+    breachStartedAt: string;
+    firedAt: string;
+    resolvedAt: string | null;
+    peakValue: number;
+    lastValue: number | null;
+    sequenceFrom: number;
+    sequenceTo: number;
+    relatedFindings: RelatedFinding[];
+    causeNote: string;
+}
+export interface IncidentRuleStatus {
+    ruleId: string;
+    title: string;
+    metric: string;
+    unit: string;
+    severity: IncidentSeverity;
+    state: IncidentState;
+    since: string | null;
+    value: number | null;
+    threshold: number;
+    recoverBelow: number;
+    valid: boolean;
+    reason?: string;
+    incidentId: string | null;
+}
+export interface IncidentsSnapshot {
+    rules: IncidentRuleStatus[];
+    incidents: Incident[];
+    serverTime: string;
+}

package/dist/core/domain/incident.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -4,3 +4,8 @@ export * from './metrics.types';
 export * from './endpoints.types';
 export * from './dashboard.types';
 export * from './telemetry.types';
+export * from './event.types';
+export * from './session.types';
+export * from './correlation.types';
+export * from './live-bucket.types';
+export * from './incident.types';

package/dist/core/domain/index.js

@@ -20,3 +20,8 @@ __exportStar(require("./metrics.types"), exports);
 __exportStar(require("./endpoints.types"), exports);
 __exportStar(require("./dashboard.types"), exports);
 __exportStar(require("./telemetry.types"), exports);
+__exportStar(require("./event.types"), exports);
+__exportStar(require("./session.types"), exports);
+__exportStar(require("./correlation.types"), exports);
+__exportStar(require("./live-bucket.types"), exports);
+__exportStar(require("./incident.types"), exports);

package/dist/core/domain/live-bucket.types.d.ts

@@ -0,0 +1,86 @@
+/**
+ * A DTO representing a live bucket of telemetry data.
+ * @property bucketId - The unique identifier for the bucket.
+ * @property sequence - The sequence number of the bucket.
+ * @property startTime - The ISO string representing when the bucket started.
+ * @property endTime - The ISO string representing when the bucket ended.
+ * @property durationMs - The duration of the bucket in milliseconds.
+ * @property committed - A boolean indicating whether the bucket has been committed.
+ * @property qualityFlags - An array of strings representing quality flags for the bucket.
+ * @property requestCount - The total number of requests recorded in the bucket.
+ * @property clientErrorCount - The total number of client errors (HTTP 4xx) recorded in the bucket.
+ * @property serverErrorCount - The total number of server errors (HTTP 5xx) recorded in the bucket.
+ * @property rps - The average requests per second (RPS) recorded in the bucket.
+ * @property averageLatencyMs - The average latency (in milliseconds)
+ * @property p50Ms - The 50th percentile latency (in milliseconds) recorded in the bucket.
+ * @property p95Ms - The 95th percentile latency (in milliseconds) recorded in the bucket.
+ * @property p99Ms - The 99th percentile latency (in milliseconds) recorded in the bucket.
+ * @property errorRate - The error rate (as a decimal) recorded in the bucket.
+ * @property runtime - An object containing runtime metrics for the bucket, including event loop lag, heap usage, heap size, RSS memory, and heap limit.
+ */
+export interface LiveBucketDto {
+    bucketId: string;
+    sequence: number;
+    startTime: string;
+    endTime: string;
+    durationMs: number;
+    committed: boolean;
+    qualityFlags: string[];
+    requestCount: number;
+    clientErrorCount: number;
+    serverErrorCount: number;
+    rps: number;
+    averageLatencyMs: number;
+    p50Ms: number;
+    p95Ms: number;
+    p99Ms: number;
+    errorRate: number;
+    runtime: {
+        eventLoopLagMs: number;
+        heapUsageBytes: number;
+        heapSizeBytes: number;
+        rssMemoryBytes: number;
+        heapLimitBytes: number;
+        cpuPercent: number;
+        cpuUserPercent: number;
+        cpuSystemPercent: number;
+    };
+}
+/**
+ * A message containing a set of live buckets.
+ * @property subscriptionId - The subscription ID for the message. If null, the message is for all subscriptions.
+ * @property sessionId - The session ID for the message.
+ * @property kind - The kind of buckets in the message. Either 'live' or 'backfill'.
+ * @property buckets - The array of live bucket DTOs.
+ * @property lastSequence - The last sequence number of the buckets in the message. If null, there are no buckets in the message.
+ * @property requestedAfterSequence - The sequence number after which the buckets were requested. If null, the request was for all buckets.
+ * @property gaps - An array of gaps in the bucket sequences. Each gap is represented as a tuple of [startSequence, endSequence].
+ * @property truncated - Whether the message was truncated due to a limit on the number of buckets returned.
+ * @property serverTime - The server time when the message was generated.
+ */
+export interface BucketsMessage {
+    subscriptionId: string | null;
+    sessionId: string;
+    kind: 'live' | 'backfill';
+    buckets: LiveBucketDto[];
+    lastSequence: number | null;
+    requestedAfterSequence: number | null;
+    gaps: Array<[number, number]>;
+    truncated: boolean;
+    serverTime: string;
+}
+/**
+ * A request for a set of buckets.
+ * @property subscriptionId - The subscription ID for the request.
+ * @property sessionId - The session ID for the request. If null, the request is for all sessions.
+ * @property afterSequence - The sequence number after which to return buckets. If null, return from the beginning.
+ * @property afterEndTime - The end time after which to return buckets. If null, return from the beginning.
+ * @property limit - The maximum number of buckets to return. If not specified, return all available buckets.
+ */
+export interface BucketsRequest {
+    subscriptionId: string;
+    sessionId: string | null;
+    afterSequence: number | null;
+    afterEndTime: string | null;
+    limit?: number;
+}

package/dist/core/domain/live-bucket.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/domain/metrics.types.d.ts

@@ -91,6 +91,31 @@ export interface LibuvHandles {
     timers: number;
     fileDescriptors: number;
 }
+/**
+ * Represents historic time series data for various metrics, including requests per second (RPS), latency, error rate, event loop lag, heap usage, heap size, resident set size (RSS) memory, total heap memory, and optional percentiles (p95 and p99).
+ * @property {T} rps - Values of requests per second (RPS) values over time.
+ * @property {T} latency - Values of latency values over time.
+ * @property {T} errorRate - Values of error rate values over time.
+ * @property {T} eventLoopLag - Values of event loop lag values over time.
+ * @property {T} heapUsage - Values of heap usage values over time.
+ * @property {T} heapSize - Values of heap size values over time.
+ * @property {T} rssMemory - Values of resident set size (RSS) memory values over time.
+ * @property {T} totalHeap - Values of total heap memory values over time (from health memory breakdown).
+ * @property {T} p95 - Optional values of 95th percentile latency values over time.
+ * @property {T} p99 - Optional values of 99th percentile latency values over time.
+ */
+interface HistoricSeries<T> {
+    rps: T;
+    latency: T;
+    errorRate: T;
+    eventLoopLag: T;
+    heapUsage: T;
+    heapSize: T;
+    rssMemory: T;
+    totalHeap: T;
+    p95?: T;
+    p99?: T;
+}
 /**
  * Represents historic time series data for various metrics, including requests per second (RPS), latency, error rate, event loop lag, heap usage, heap size, resident set size (RSS) memory, total heap memory, and optional percentiles (p95 and p99).
  * @property {number[]} rps - An array of requests per second (RPS) values over time.
@@ -104,16 +129,21 @@ export interface LibuvHandles {
  * @property {number[]} [p95] - Optional array of 95th percentile latency values over time.
  * @property {number[]} [p99] - Optional array of 99th percentile latency values over time.
  */
-export interface HistoricTimeSeries {
-    rps: number[];
-    latency: number[];
-    errorRate: number[];
-    eventLoopLag: number[];
-    heapUsage: number[];
-    heapSize: number[];
-    rssMemory: number[];
-    totalHeap: number[];
-    p95?: number[];
-    p99?: number[];
+export interface HistoricTimeSeries extends HistoricSeries<number[]> {
+}
+/**
+ * Represents historic tick series data for various metrics, including requests per second (RPS), latency, error rate, event loop lag, heap usage, heap size, resident set size (RSS) memory, total heap memory, and optional percentiles (p95 and p99).
+ * @property {number} rps - The requests per second (RPS) value at a specific tick.
+ * @property {number} latency - The latency value at a specific tick.
+ * @property {number} errorRate - The error rate value at a specific tick.
+ * @property {number} eventLoopLag - The event loop lag value at a specific tick.
+ * @property {number} heapUsage - The heap usage value at a specific tick.
+ * @property {number} heapSize - The heap size value at a specific tick.
+ * @property {number} rssMemory - The resident set size (RSS) memory value at a specific tick.
+ * @property {number} totalHeap - The total heap memory value at a specific tick (from health memory breakdown).
+ * @property {number} [p95] - Optional 95th percentile latency value at a specific tick.
+ * @property {number} [p99] - Optional 99th percentile latency value at a specific tick.
+ */
+export interface HistoricTickSeries extends HistoricSeries<number> {
 }
 export {};

package/dist/core/domain/session.types.d.ts

@@ -0,0 +1,93 @@
+import type { Incident } from './incident.types';
+/**
+ * Represents the status of a session, which can be either 'RUNNING', 'COMPLETED', or 'INTERRUPTED'.
+ * - 'RUNNING': The session is currently active and ongoing.
+ * - 'COMPLETED': The session has finished successfully.
+ * - 'INTERRUPTED': The session was interrupted before completion, possibly due to an error or unexpected shutdown.
+ */
+export type SessionStatus = 'RUNNING' | 'COMPLETED' | 'INTERRUPTED';
+/**
+ * Represents a record of a session, containing essential information about the session's lifecycle and status.
+ * @property {string} sessionId - A unique identifier for the session.
+ * @property {number} sessionNumber - A sequential number representing the order of the session.
+ * @property {string} startedAt - The ISO string representing when the session started.
+ * @property {string | null} endedAt - The ISO string representing when the session ended, or null if it is currently running.
+ * @property {string | null} lastPersistedAt - The ISO string representing when the session's data was last persisted, or null if it has not been persisted yet.
+ * @property {number} lastCommittedSequence - The last committed sequence number for the session's data.
+ * @property {SessionStatus} status - The current status of the session, which can be 'RUNNING', 'COMPLETED', or 'INTERRUPTED'.
+ */
+export type SessionRecord = {
+    sessionId: string;
+    sessionNumber: number;
+    startedAt: string;
+    endedAt: string | null;
+    lastPersistedAt: string | null;
+    lastCommittedSequence: number;
+    status: SessionStatus;
+};
+/**
+ * Represents a manifest of sessions, containing a version number and an array of session records.
+ * @property {number} version - The version number of the session manifest.
+ * @property {SessionRecord[]} sessions - An array of session records, each representing a single session's information.
+ */
+export interface SessionManifest {
+    version: 2;
+    sessions: SessionRecord[];
+}
+export interface SessionSummaryPoint {
+    startTime: string;
+    durationMs: number;
+    requestCount: number;
+    rps: number;
+    maxRps: number;
+    p95: number;
+    serverErrorRate: number;
+    clientErrorCount: number;
+    serverErrorCount: number;
+}
+export interface SessionRouteImpact {
+    method: string;
+    route: string;
+    requestCount: number;
+    impactedRequests: number;
+    p95: number;
+    serverErrorRate: number;
+}
+export interface SessionSummary {
+    sessionId: string;
+    sessionNumber: number;
+    status: SessionStatus;
+    startedAt: string;
+    endedAt: string | null;
+    windowStart: string;
+    windowEnd: string;
+    measuredMs: number;
+    traffic: {
+        requestCount: number;
+        avgRps: number;
+        peakRps: number;
+    };
+    latency: {
+        p50: number;
+        p95: number;
+        p99: number;
+        max: number;
+    };
+    errors: {
+        serverErrorCount: number;
+        serverErrorRate: number;
+        clientErrorCount: number;
+    };
+    incidents: Incident[];
+    topRoutes: SessionRouteImpact[];
+    series: {
+        resolutionMs: number;
+        points: SessionSummaryPoint[];
+    };
+    quality: {
+        bucketCount: number;
+        missingIntervals: number;
+        conflicts: number;
+        complete: boolean;
+    };
+}

package/dist/core/domain/session.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });