@loadstrike/loadstrike-sdk 1.0.31001 → 1.0.31601

package/dist/cjs/runtime.js

@@ -13,6 +13,8 @@ const cluster_js_1 = require("./cluster.js");
 const correlation_js_1 = require("./correlation.js");
 const transports_js_1 = require("./transports.js");
 const reporting_js_1 = require("./reporting.js");
+const report_history_js_1 = require("./report-history.js");
+const local_report_input_js_1 = require("./local-report-input.js");
 const sinks_js_1 = require("./sinks.js");
 const load_engine_v2_js_1 = require("./load-engine-v2.js");
 const iteration_observations_js_1 = require("./iteration-observations.js");
@@ -291,6 +293,28 @@ class MeasurementAccumulator {
             moreOrEq1200: left.moreOrEq1200 + right.moreOrEq1200
         }, allRequestCount, durationMs);
     }
+    /**
+     * Projects only the cumulative fields used by the private HTML-report
+     * history. Legacy distributions deliberately omit latency so this cadence
+     * path never scans their retained per-request arrays.
+     */
+    buildReportHistoryMeasurement() {
+        return projectNativeReportHistoryMeasurement(this.count, this.allBytes, this.useHistogram ? this.latencyHistogram : undefined);
+    }
+    /**
+     * Combines only bounded native latency state plus exact counters. It does
+     * not materialize status rows or any public measurement DTO.
+     */
+    buildCombinedReportHistoryMeasurement(other) {
+        const count = this.count + other.count;
+        const bytes = this.allBytes + other.allBytes;
+        if (!this.useHistogram || !other.useHistogram) {
+            return projectNativeReportHistoryMeasurement(count, bytes);
+        }
+        const latency = this.latencyHistogram.clone();
+        latency.merge(other.latencyHistogram);
+        return projectNativeReportHistoryMeasurement(count, bytes, latency);
+    }
     histogramSnapshot() {
         return {
             count: this.count,
@@ -304,6 +328,24 @@ class MeasurementAccumulator {
         };
     }
 }
+function projectNativeReportHistoryMeasurement(count, bytes, latency) {
+    const measurement = {
+        count,
+        bytes,
+        approximate: latency?.maxRelativeError !== undefined
+            && latency.maxRelativeError > 0
+    };
+    if (!latency || latency.count === 0n) {
+        return measurement;
+    }
+    return {
+        ...measurement,
+        percent50Ms: Number(latency.percentile(0.5)) / 1000,
+        percent75Ms: Number(latency.percentile(0.75)) / 1000,
+        percent95Ms: Number(latency.percentile(0.95)) / 1000,
+        percent99Ms: Number(latency.percentile(0.99)) / 1000
+    };
+}
 function buildHistogramMeasurement(snapshot, allRequestCount, durationMs) {
     const count = snapshot.count;
     const totalDurationMs = Math.max(durationMs, 0);
@@ -642,6 +684,21 @@ class ScenarioStatsAccumulator {
         step.record(reply, observedLatencyMs);
         return step.sortIndex;
     }
+    /**
+     * Captures the bounded, private history view without building scenario
+     * steps, status rows, plugins, aliases, or any other public result shape.
+     */
+    buildReportHistorySnapshot() {
+        const ok = this.ok.buildReportHistoryMeasurement();
+        const failed = this.fail.buildReportHistoryMeasurement();
+        return {
+            scenarioName: this.scenarioName,
+            sortIndex: this.sortIndex,
+            all: this.ok.buildCombinedReportHistoryMeasurement(this.fail),
+            ...(ok.count > 0 ? { ok } : {}),
+            ...(failed.count > 0 ? { failed } : {})
+        };
+    }
     /**
      * Builds the configured payload or helper object.
      * Use this when all builder inputs are ready to be materialized.
@@ -3509,6 +3566,58 @@ class LoadStrikeRunner {
         licenseSession = await licenseClient.acquireLicenseLease(licensePayload);
         const loggerSetup = createLoggerSetup(this.options.loggerConfig, this.options.minimumLogLevel, this.options, testInfo, nodeInfo);
         const runLogger = loggerSetup.logger;
+        const htmlReportHistoryRequested = (this.options.reportsEnabled ?? true)
+            && normalizeReportFormats(this.options.reportFormats ?? ["html", "txt", "csv", "md"]).includes("html");
+        const distributedReportHistory = isDistributedReportHistoryExecution(clusterMode, this.options);
+        let localReportInput = htmlReportHistoryRequested
+            && distributedReportHistory
+            ? (0, local_report_input_js_1.distributedLocalReportInput)()
+            : (0, local_report_input_js_1.emptyLocalReportInput)();
+        let reportHistoryCollector;
+        let reportHistoryLifecycle;
+        if (htmlReportHistoryRequested && !distributedReportHistory) {
+            const warnReportHistoryFailure = (category, error) => {
+                const exceptionClasses = error === undefined
+                    ? ""
+                    : `; exception_classes=${(0, report_history_js_1.sanitizedExceptionClassChain)(error)}`;
+                try {
+                    runLogger.warn(`LoadStrike report history unavailable: ${category}${exceptionClasses}.`);
+                }
+                catch {
+                    // Report-only diagnostics are best-effort.
+                }
+            };
+            reportHistoryCollector = new report_history_js_1.ReportHistoryCollector({
+                scenarioCount: selectedScenarios.length,
+                onCaptureError: (error) => warnReportHistoryFailure("capture_failure", error)
+            });
+            if (!reportHistoryCollector.available) {
+                warnReportHistoryFailure("budget_pressure");
+            }
+            const snapshotFactory = () => Array.from(scenarioAccumulators.values())
+                .map((value) => value.buildReportHistorySnapshot())
+                .sort((left, right) => (left.sortIndex ?? 0) - (right.sortIndex ?? 0)
+                || left.scenarioName.localeCompare(right.scenarioName));
+            const reportHistoryWorker = new report_history_js_1.ReportHistoryWorker({
+                collector: reportHistoryCollector,
+                cadenceSeconds: resolvedReportHistoryCadenceSeconds(this.options.reportingIntervalSeconds ?? 5),
+                snapshotFactory,
+                onFailure: (category, exceptionClasses) => {
+                    try {
+                        runLogger.warn(`LoadStrike report history unavailable: ${category}; exception_classes=${exceptionClasses}.`);
+                    }
+                    catch {
+                        // Report-only diagnostics are best-effort.
+                    }
+                }
+            });
+            reportHistoryLifecycle = new report_history_js_1.ReportHistoryLifecycleCoordinator({
+                scenarioCount: selectedScenarios.length,
+                start: () => reportHistoryWorker.start(),
+                stopAndFinalize: () => reportHistoryWorker.stopAndFinalize(),
+                stopWithoutFinalizing: () => reportHistoryWorker.stopWithoutFinalizing()
+            });
+        }
         const scenarioStartInfos = selectedScenarios.map((scenario, index) => {
             const startInfo = {
                 scenarioName: scenario.name,
@@ -3618,7 +3727,7 @@ class LoadStrikeRunner {
                 realtimeInFlight = false;
             }
         };
-        const reportingIntervalMs = Math.max(Math.trunc((this.options.reportingIntervalSeconds ?? 5) * 1000), 1);
+        const reportingIntervalMs = boundedReportingIntervalMs(this.options.reportingIntervalSeconds ?? 5);
         const triggerRealtimeSnapshot = () => {
             if (realtimeCurrent) {
                 return;
@@ -3705,6 +3814,7 @@ class LoadStrikeRunner {
                     iterationObservationRunId,
                     iterationObservationResultOwnerId,
                     iterationObservationProcessGroup,
+                    reportHistoryLifecycle,
                     executeScenarioInvocation: (targetScenario, context, operation) => this.executeScenarioInvocation(targetScenario, context, operation),
                     invokeBeforeScenario: (runtimePolicies, scenarioName) => this.invokeBeforeScenario(runtimePolicies, scenarioName, policyErrors, runtimePolicyErrorMode),
                     invokeAfterScenario: (runtimePolicies, scenarioName, stats) => this.invokeAfterScenario(runtimePolicies, scenarioName, stats, policyErrors, runtimePolicyErrorMode),
@@ -3792,9 +3902,14 @@ class LoadStrikeRunner {
                 ...iterationObservationReporter.buildWarnings()
             ];
             result.pluginsData = mergePluginData(result.pluginsData, await this.collectPluginData(plugins, attachRunResultAliases(result), pluginLifecycleErrors));
+            if (reportHistoryCollector) {
+                localReportInput = {
+                    history: reportHistoryCollector.toProjection()
+                };
+            }
             const finalizedResult = attachRunResultAliases(result);
             finalizedResult.logFiles = mergeStringArrays(finalizedResult.logFiles, loggerSetup.logFiles);
-            finalizedResult.reportFiles = this.writeReports(finalizedResult);
+            finalizedResult.reportFiles = this.writeReports(finalizedResult, localReportInput);
             finalizedResult.disabledSinks = sinkStates.filter((x) => x.disabled).map((x) => x.name);
             await this.emitRunResult(sinkStates, finalizedResult, sinkRetryCount, sinkRetryBackoffMs, sinkErrors, testInfo.sessionId, runLogger);
             await this.stopSinks(sinkStates, sinkRetryCount, sinkRetryBackoffMs, sinkErrors, testInfo.sessionId, runLogger);
@@ -3805,6 +3920,7 @@ class LoadStrikeRunner {
             return finalizedResult;
         }
         finally {
+            reportHistoryLifecycle?.stopWithoutFinalizing();
             await stopRealtimeReporting();
             if (!iterationObservationsFinalized) {
                 await iterationObservationReporter.sealAndDrain().catch(() => { });
@@ -4282,7 +4398,7 @@ class LoadStrikeRunner {
             message: String(error ?? "runtime policy callback failed")
         });
     }
-    writeReports(result) {
+    writeReports(result, localReportInput = (0, local_report_input_js_1.emptyLocalReportInput)()) {
         const reportsEnabled = this.options.reportsEnabled ?? true;
         if (!reportsEnabled) {
             return [];
@@ -4307,7 +4423,7 @@ class LoadStrikeRunner {
                 (0, node_fs_1.writeFileSync)(path, (0, reporting_js_1.buildDotnetMarkdownReport)(nodeStats), "utf8");
             }
             else if (format === "html") {
-                (0, node_fs_1.writeFileSync)(path, (0, reporting_js_1.buildDotnetHtmlReport)(nodeStats), "utf8");
+                (0, node_fs_1.writeFileSync)(path, (0, reporting_js_1.buildDotnetHtmlReport)(nodeStats, localReportInput), "utf8");
             }
             written.push(path);
         }
@@ -4341,6 +4457,19 @@ function hasPluginRows(value) {
     }
     return value.tables.some((table) => Array.isArray(table.rows) && table.rows.length > 0);
 }
+function boundedReportingIntervalMs(seconds) {
+    if (!Number.isFinite(seconds) || seconds <= 0) {
+        return 1;
+    }
+    const milliseconds = seconds * 1000;
+    if (!Number.isFinite(milliseconds) || milliseconds >= 2147483647) {
+        return 2147483647;
+    }
+    return Math.max(Math.trunc(milliseconds), 1);
+}
+function resolvedReportHistoryCadenceSeconds(seconds) {
+    return boundedReportingIntervalMs(seconds) / 1000;
+}
 async function executeV2FixedArrivals(args) {
     const { rate, intervalNs, totalArrivals, budget, cancellationToken, shouldStopNow, nextInstanceInfo, runBombingInvocation, logger, scenarioName, deadlineOffsetsNs, tolerancesNs, ownedOrdinals, shardIndex = 0, shardCount = 1, telemetry, segment } = args;
     const segmentStartNs = process.hrtime.bigint();
@@ -4477,7 +4606,15 @@ function maxBigInt(left, right) {
     return left > right ? left : right;
 }
 async function executeScenarioRuntime(args) {
-    const { scenario, scenarioIndex, scenarioCount, options, logger, nodeInfo, testInfo, policies, restartIterationMaxAttempts, allRegisteredMetrics, scenarioRuntimes, stepRuntimes, scenarioAccumulators, scenarioDurationsMs, stopTestState, testAbortController, loadEngineV2Budget, loadEngineV2Telemetry, iterationObservationReporter, iterationObservationRunId = testInfo.sessionId, iterationObservationResultOwnerId = "", iterationObservationProcessGroup = 0, executeScenarioInvocation, invokeBeforeScenario, invokeAfterScenario, invokeBeforeStep, invokeAfterStep } = args;
+    const { scenario, scenarioIndex, scenarioCount, options, logger, nodeInfo, testInfo, policies, restartIterationMaxAttempts, allRegisteredMetrics, scenarioRuntimes, stepRuntimes, scenarioAccumulators, scenarioDurationsMs, stopTestState, testAbortController, loadEngineV2Budget, loadEngineV2Telemetry, iterationObservationReporter, iterationObservationRunId = testInfo.sessionId, iterationObservationResultOwnerId = "", iterationObservationProcessGroup = 0, reportHistoryLifecycle, executeScenarioInvocation, invokeBeforeScenario, invokeAfterScenario, invokeBeforeStep, invokeAfterStep } = args;
+    let reportHistoryExecutionEnded = false;
+    const endReportHistoryExecution = async () => {
+        if (reportHistoryExecutionEnded) {
+            return;
+        }
+        reportHistoryExecutionEnded = true;
+        await reportHistoryLifecycle?.scenarioExecutionEnded();
+    };
     const scenarioStartedMs = Date.now();
     const scenarioContextData = {};
     const registeredMetrics = [];
@@ -5298,6 +5435,7 @@ async function executeScenarioRuntime(args) {
         })));
         await invokeBeforeScenario(policies, scenario.name);
         await runWarmUpAsync();
+        reportHistoryLifecycle?.scenarioBombingStarted();
         accumulator.setCurrentOperation("Bombing");
         const simulations = scenario.getSimulations();
         if (!simulations.length) {
@@ -5331,6 +5469,7 @@ async function executeScenarioRuntime(args) {
             }
         }
         accumulator.setCurrentOperation(stopScenario || stopTestState.value ? "Stop" : "Complete");
+        await endReportHistoryExecution();
         await invokeAfterScenario(policies, scenario.name, runtime);
     }
     catch (error) {
@@ -5347,6 +5486,7 @@ async function executeScenarioRuntime(args) {
         }
     }
     finally {
+        await endReportHistoryExecution();
         scenarioDurationsMs.set(scenario.name, Math.max(Date.now() - scenarioStartedMs, 0));
         try {
             await scenario.invokeClean({
@@ -7280,6 +7420,11 @@ function resolveClusterExecutionMode(options) {
     }
     return "single";
 }
+function isDistributedReportHistoryExecution(clusterMode, options) {
+    return clusterMode !== "single"
+        || options.loadEngineV2SegmentLifecycleOverride !== undefined
+        || Math.max(Math.trunc(options.clusterShardCount ?? 1), 1) > 1;
+}
 function buildEmptyNodeStats(args) {
     return attachNodeStatsAliases({
         startedUtc: args.startedUtc,
@@ -11111,6 +11256,7 @@ function buildGroupedCorrelationRows(rows) {
             LatencyMinMs: latencySamples.length ? formatOptionalLatency(latencySamples[0]) : "",
             LatencyMeanMs: latencySamples.length ? formatOptionalLatency(latencySamples.reduce((sum, value) => sum + value, 0) / latencySamples.length) : "",
             LatencyP50Ms: latencySamples.length ? formatOptionalLatency(percentile(latencySamples, 0.5)) : "",
+            LatencyP75Ms: latencySamples.length ? formatOptionalLatency(percentile(latencySamples, 0.75)) : "",
             LatencyP80Ms: latencySamples.length ? formatOptionalLatency(percentile(latencySamples, 0.8)) : "",
             LatencyP85Ms: latencySamples.length ? formatOptionalLatency(percentile(latencySamples, 0.85)) : "",
             LatencyP90Ms: latencySamples.length ? formatOptionalLatency(percentile(latencySamples, 0.9)) : "",
@@ -11323,6 +11469,8 @@ exports.__loadstrikeTestExports = {
     buildThresholdCheckExpression,
     buildTrackingLeaseKey,
     buildTrackingRunNamespace,
+    boundedReportingIntervalMs,
+    resolvedReportHistoryCadenceSeconds,
     clusterNodeResultToNodeStats,
     combineAbortSignals,
     computeScenarioRequestCount,
@@ -11342,6 +11490,7 @@ exports.__loadstrikeTestExports = {
     formatUtcReportTimestamp,
     hasPluginRows,
     inferRuntimeLegacyHttpResponseSource,
+    isDistributedReportHistoryExecution,
     isComparisonFailed,
     loadJsonObject,
     logLevelOrder,

package/dist/esm/local-report-input.js

@@ -0,0 +1,17 @@
+export function emptyLocalReportInput() {
+    return {
+        history: {
+            status: "available",
+            points: []
+        }
+    };
+}
+export function distributedLocalReportInput() {
+    return {
+        history: {
+            status: "unavailable",
+            reasonCategory: "distributed_temporal_aggregation_unavailable",
+            points: []
+        }
+    };
+}