@loadstrike/loadstrike-sdk 1.0.30401 → 1.0.31001

package/dist/esm/sinks.js

@@ -6,7 +6,26 @@ import { createSocket } from "node:dgram";
 import { gzip } from "node:zlib";
 import { Pool } from "pg";
 import { serializeIterationObservationBatchGzipJson } from "./iteration-observations.js";
+import { redactIterationObservationSecrets } from "./iteration-observation-diagnostics.js";
 const PORTAL_RUN_TOKEN_PROVIDER = Symbol.for("loadstrike.internal.portal-run-token-provider");
+const MAXIMUM_HTTP_RESPONSE_BODY_BYTES = 256 * 1024;
+const MAXIMUM_HTTP_METADATA_CHARACTERS = 256;
+const HTTP_METADATA_TRUNCATION_SUFFIX = " [truncated]";
+class ReportingSinkHttpError extends Error {
+    constructor(sinkName, status, statusText, requestId) {
+        const normalizedStatus = Number.isFinite(status) ? Math.max(Math.trunc(status), 0) : 0;
+        const normalizedStatusText = normalizeHttpMetadata(statusText);
+        const normalizedRequestId = normalizeHttpMetadata(requestId);
+        super(`${sinkName} write failed with HTTP status ${normalizedStatus}`
+            + (normalizedStatusText ? ` ${normalizedStatusText}` : "")
+            + (normalizedRequestId ? ` (requestId=${normalizedRequestId})` : "")
+            + ".");
+        this.name = "ReportingSinkHttpError";
+        this.status = normalizedStatus;
+        this.statusText = normalizedStatusText;
+        this.requestId = normalizedRequestId;
+    }
+}
 function gzipJsonAsync(value) {
     const json = Buffer.from(JSON.stringify(value), "utf8");
     return new Promise((resolve, reject) => {
@@ -2202,6 +2221,7 @@ function removeSdkPercentileFields(event) {
 }
 function createIterationObservationEvents(session, batch) {
     const events = [];
+    const occurredUtc = dateFromUtcNanoseconds(batch.createdUtcNs);
     for (const observation of batch.observations) {
         const tags = {
             run_id: batch.runId,
@@ -2214,7 +2234,7 @@ function createIterationObservationEvents(session, batch) {
         events.push({
             runId: batch.runId,
             eventType: "iteration.observation",
-            occurredUtc: new Date(),
+            occurredUtc,
             sessionId: batch.sessionId,
             testSuite: session.testSuite,
             testName: session.testName,
@@ -2249,7 +2269,7 @@ function createIterationObservationEvents(session, batch) {
             events.push({
                 runId: batch.runId,
                 eventType: "iteration.step",
-                occurredUtc: new Date(),
+                occurredUtc,
                 sessionId: batch.sessionId,
                 testSuite: session.testSuite,
                 testName: session.testName,
@@ -2280,10 +2300,11 @@ function createIterationObservationEvents(session, batch) {
     return events;
 }
 function createIterationCompletionEvents(session, completion) {
+    const occurredUtc = dateFromUtcNanoseconds(completion.completedUtcNs);
     return [{
             runId: completion.runId,
             eventType: "observation.stream.completed",
-            occurredUtc: new Date(),
+            occurredUtc,
             sessionId: completion.sessionId,
             testSuite: session.testSuite,
             testName: session.testName,
@@ -2342,6 +2363,22 @@ function portalEventId(event, index) {
     });
     return `lsr_${createHash("sha256").update(material).digest("hex").slice(0, 40)}`;
 }
+function dateFromUtcNanoseconds(value) {
+    try {
+        const nanoseconds = BigInt(value);
+        if (nanoseconds < 0n) {
+            return new Date(0);
+        }
+        const milliseconds = nanoseconds / 1000000n;
+        const numeric = Number(milliseconds);
+        return Number.isFinite(numeric) && numeric <= 8640000000000000
+            ? new Date(numeric)
+            : new Date(0);
+    }
+    catch {
+        return new Date(0);
+    }
+}
 function addMeasurementFields(fields, prefix, measurement) {
     const request = measurement?.request ?? { count: 0, percent: 0, rps: 0 };
     const latency = measurement?.latency ?? {
@@ -3533,22 +3570,85 @@ async function postWithTimeout(fetchImpl, url, init, timeoutMs, sinkName) {
     const timer = setTimeout(() => controller.abort(), Math.max(timeoutMs, 1));
     try {
         const response = await fetchImpl(url, { ...init, signal: controller.signal });
-        const body = await readResponseBodyText(response);
         if (!response.ok) {
-            throw new Error(`${sinkName} write failed with status ${response.status}: ${body}`);
+            throw new ReportingSinkHttpError(sinkName, response.status, readHttpResponseStatusText(response), readHttpResponseRequestId(response));
         }
-        return body;
+        return await readResponseBodyText(response);
     }
     finally {
         clearTimeout(timer);
     }
 }
 async function readResponseBodyText(response) {
-    const candidate = response;
-    if (typeof candidate.text !== "function") {
+    const body = response.body;
+    if (body && typeof body.getReader === "function") {
+        const reader = body.getReader();
+        const chunks = [];
+        let bytes = 0;
+        try {
+            while (true) {
+                const next = await reader.read();
+                if (next.done)
+                    break;
+                if (!next.value)
+                    continue;
+                if (bytes + next.value.byteLength > MAXIMUM_HTTP_RESPONSE_BODY_BYTES) {
+                    await reader.cancel();
+                    throw new Error("Reporting sink response exceeded the bounded response limit.");
+                }
+                chunks.push(next.value);
+                bytes += next.value.byteLength;
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+        return Buffer.concat(chunks.map((chunk) => Buffer.from(chunk))).toString("utf8");
+    }
+    return "";
+}
+function readHttpResponseStatusText(response) {
+    try {
+        return normalizeHttpMetadata(response.statusText);
+    }
+    catch {
+        return "";
+    }
+}
+function readHttpResponseRequestId(response) {
+    for (const name of [
+        "x-request-id",
+        "x-correlation-id",
+        "request-id",
+        "traceparent"
+    ]) {
+        try {
+            const value = response.headers?.get(name);
+            if (value) {
+                return normalizeHttpMetadata(value);
+            }
+        }
+        catch {
+            return "";
+        }
+    }
+    return "";
+}
+function normalizeHttpMetadata(value) {
+    let text;
+    try {
+        const source = String(value ?? "");
+        text = source.length <= MAXIMUM_HTTP_METADATA_CHARACTERS
+            ? source
+            : source.slice(0, MAXIMUM_HTTP_METADATA_CHARACTERS - HTTP_METADATA_TRUNCATION_SUFFIX.length) + HTTP_METADATA_TRUNCATION_SUFFIX;
+    }
+    catch {
         return "";
     }
-    return String(await candidate.text());
+    return redactIterationObservationSecrets(Buffer.from(text, "utf8").toString("utf8")
+        .replace(/[\u0000-\u001F\u007F-\u009F]/gu, " ")
+        .replace(/\s{2,}/gu, " ")
+        .trim());
 }
 function validatePortalIngestResponse(responseBody) {
     const text = String(responseBody ?? "").trim();
@@ -3601,6 +3701,8 @@ export const __loadstrikeTestExports = {
     cloneScenarioStats,
     cloneSessionStartInfo,
     createFinalStatsEvents,
+    createIterationCompletionEvents,
+    createIterationObservationEvents,
     createRealtimeStatsEvents,
     createRunResultEvents,
     createReportingEvent,
@@ -3617,6 +3719,7 @@ export const __loadstrikeTestExports = {
     normalizeStringMap,
     optionNumber,
     optionString,
+    portalEventPayload,
     pickBooleanValue,
     pickRecordValue,
     postWithTimeout,

package/dist/esm/transports.js

@@ -596,14 +596,10 @@ class WebSocketEndpointDefinitionModel extends TrafficEndpointDefinitionModel {
             parsed = new URL(url);
         }
         catch {
-            // Diagnostic text only; no connection is opened here.
-            // nosemgrep: vulnerability-tools.semgrep-rules.javascript.lang.security.detect-insecure-websocket
-            throw new Error("Url must be an absolute ws:// or wss:// URI.");
+            throw new Error("Url must be an absolute WebSocket URI using the ws or wss scheme.");
         }
         if (parsed.protocol !== "ws:" && parsed.protocol !== "wss:") {
-            // Diagnostic text only; no connection is opened here.
-            // nosemgrep: vulnerability-tools.semgrep-rules.javascript.lang.security.detect-insecure-websocket
-            throw new Error("Url must be an absolute ws:// or wss:// URI.");
+            throw new Error("Url must be an absolute WebSocket URI using the ws or wss scheme.");
         }
         if (this.ConnectTimeoutSeconds <= 0) {
             throw new RangeError("ConnectTimeout must be greater than zero.");
@@ -3132,14 +3128,10 @@ function validateWebSocketEndpoint(endpoint, mode) {
         parsed = new URL(url);
     }
     catch {
-        // Diagnostic text only; no connection is opened here.
-        // nosemgrep: vulnerability-tools.semgrep-rules.javascript.lang.security.detect-insecure-websocket
-        throw new Error("Url must be an absolute ws:// or wss:// URI.");
+        throw new Error("Url must be an absolute WebSocket URI using the ws or wss scheme.");
     }
     if (parsed.protocol !== "ws:" && parsed.protocol !== "wss:") {
-        // Diagnostic text only; no connection is opened here.
-        // nosemgrep: vulnerability-tools.semgrep-rules.javascript.lang.security.detect-insecure-websocket
-        throw new Error("Url must be an absolute ws:// or wss:// URI.");
+        throw new Error("Url must be an absolute WebSocket URI using the ws or wss scheme.");
     }
     const connectMs = optionNumber(options, "ConnectTimeoutMs", "connectTimeoutMs");
     const connectSeconds = optionNumber(options, "ConnectTimeoutSeconds", "connectTimeoutSeconds", "ConnectTimeout", "connectTimeout");
@@ -3569,7 +3561,13 @@ function extractJsonPath(value, arrayPath) {
     if (!normalized) {
         return value;
     }
-    const tokens = normalized.replace(/\[(\d+)\]/g, ".$1").split(".").filter((x) => x.length > 0);
+    let tokens;
+    try {
+        tokens = safeJsonPathSegments(normalized.replace(/\[(\d+)\]/g, ".$1"));
+    }
+    catch {
+        return null;
+    }
     for (const token of tokens) {
         if (current == null) {
             return null;
@@ -3579,13 +3577,17 @@ function extractJsonPath(value, arrayPath) {
             if (!Number.isInteger(index) || index < 0 || index >= current.length) {
                 return null;
             }
-            current = current[index];
+            current = current.at(index);
             continue;
         }
-        if (!isRecord(current) || !(token in current)) {
+        if (!isRecord(current)) {
             return null;
         }
-        current = current[token];
+        const descriptor = Object.getOwnPropertyDescriptor(current, token);
+        if (!descriptor || !("value" in descriptor)) {
+            return null;
+        }
+        current = descriptor.value;
     }
     return current;
 }
@@ -3602,7 +3604,7 @@ function parseMaybeJson(value) {
     }
 }
 function headersToRecord(value) {
-    const headers = {};
+    const headers = Object.create(null);
     value.forEach((headerValue, key) => {
         headers[key] = headerValue;
     });
@@ -3956,11 +3958,22 @@ function extractTrackingValue(payload, selector) {
             return null;
         }
         let current = body;
-        for (const segment of selector.slice("json:".length).trim().replace(/^\$\./, "").split(".").filter(Boolean)) {
+        const path = selector.slice("json:".length).trim().replace(/^\$\./, "");
+        let segments;
+        try {
+            segments = safeJsonPathSegments(path);
+        }
+        catch {
+            return null;
+        }
+        for (const segment of segments) {
             if (!isRecord(current)) {
                 return null;
             }
-            current = current[segment];
+            if (!Object.prototype.hasOwnProperty.call(current, segment)) {
+                return null;
+            }
+            current = readOwnJsonProperty(current, segment);
         }
         return current == null ? null : String(current);
     }
@@ -3991,23 +4004,61 @@ function injectTrackingValue(payload, selector, value) {
 }
 function setJsonBodyValue(body, path, value) {
     const target = parseBodyObject(body) ?? {};
-    const clone = cloneBody(target);
-    const segments = path.split(".").filter(Boolean);
+    const clone = cloneJsonRecord(target);
+    const segments = safeJsonPathSegments(path);
     if (!segments.length) {
         return clone;
     }
     let current = clone;
     for (let i = 0; i < segments.length - 1; i += 1) {
         const segment = segments[i];
-        const next = current[segment];
+        let next = readOwnJsonProperty(current, segment);
         if (!isRecord(next)) {
-            current[segment] = {};
+            next = {};
+            defineJsonProperty(current, segment, next);
         }
-        current = current[segment];
+        current = next;
     }
-    current[segments[segments.length - 1]] = value;
+    defineJsonProperty(current, segments[segments.length - 1], value);
     return clone;
 }
+const FORBIDDEN_JSON_PATH_SEGMENTS = new Set(["__proto__", "prototype", "constructor"]);
+function safeJsonPathSegments(path) {
+    const segments = path.split(".").filter(Boolean);
+    const forbidden = segments.find((segment) => FORBIDDEN_JSON_PATH_SEGMENTS.has(segment));
+    if (forbidden) {
+        throw new Error(`Tracking selector contains forbidden JSON path segment '${forbidden}'.`);
+    }
+    return segments;
+}
+function defineJsonProperty(target, key, value) {
+    Object.defineProperty(target, key, {
+        configurable: true,
+        enumerable: true,
+        value,
+        writable: true
+    });
+}
+function readOwnJsonProperty(target, key) {
+    const descriptor = Object.getOwnPropertyDescriptor(target, key);
+    return descriptor && "value" in descriptor ? descriptor.value : undefined;
+}
+function cloneJsonRecord(source) {
+    const target = {};
+    for (const [key, value] of Object.entries(source)) {
+        defineJsonProperty(target, key, cloneJsonValue(value));
+    }
+    return target;
+}
+function cloneJsonValue(value) {
+    if (Array.isArray(value)) {
+        return value.map((entry) => cloneJsonValue(entry));
+    }
+    if (isRecord(value)) {
+        return cloneJsonRecord(value);
+    }
+    return value;
+}
 function parseBodyObject(body) {
     if (body instanceof Uint8Array) {
         return parseBodyObject(new TextDecoder().decode(body));
@@ -4616,8 +4667,10 @@ export const __loadstrikeTestExports = {
     createNatsHeaders,
     createRedisStreamPayload,
     deserializeBrokerPayloadBody,
+    extractJsonPath,
     extractTrackingValue,
     fromKafkaHeaders,
+    headersToRecord,
     headerValue,
     attachDotNetTrackingPayloadAliases,
     attachPayloadHelpers,

package/dist/types/iteration-observation-diagnostics.d.ts

@@ -0,0 +1,21 @@
+export interface IterationObservationDiagnosticLogger {
+    debug(message: string): void | PromiseLike<void>;
+    warn(message: string): void | PromiseLike<void>;
+    error(message: string): void | PromiseLike<void>;
+}
+export interface IterationObservationDiagnosticContext {
+    sinkName: string;
+    operation: "observation-batch" | "observation-stream-completion" | "reporting-sink-action";
+    phase?: string;
+    runId: string;
+    resultOwnerId: string;
+    batchId?: string;
+    batchSequence64?: string;
+    observationCount: number;
+    attempt: number;
+    maximumAttempts: number;
+    nextDelayMs?: number;
+}
+export declare function logIterationObservationFailure(logger: IterationObservationDiagnosticLogger | undefined, level: "warn" | "error", context: IterationObservationDiagnosticContext, error: unknown): void;
+export declare function logIterationObservationRecovery(logger: IterationObservationDiagnosticLogger | undefined, context: IterationObservationDiagnosticContext): void;
+export declare function redactIterationObservationSecrets(value: string): string;

package/dist/types/iteration-observations.d.ts

@@ -1,3 +1,4 @@
+import { type IterationObservationDiagnosticLogger } from "./iteration-observation-diagnostics.js";
 export declare const ITERATION_OBSERVATION_SCHEMA_VERSION = "loadstrike.iteration-observation/1";
 export declare const ITERATION_OBSERVATION_BATCH_SCHEMA_VERSION = "loadstrike.iteration-batch/1";
 export declare const ITERATION_OBSERVATION_STREAM_COMPLETION_SCHEMA_VERSION = "loadstrike.iteration-stream-completion/1";
@@ -192,6 +193,9 @@ export interface IterationObservationReporterOptions {
     buffer?: ProcessIterationObservationBuffer;
     clock?: IterationObservationClock;
     skipValidation?: boolean;
+    sinkRetryCount?: number;
+    sinkRetryBackoffMs?: number;
+    logger?: IterationObservationDiagnosticLogger;
 }
 export declare class IterationObservationReporter {
     private readonly options;
@@ -215,6 +219,7 @@ export declare class IterationObservationReporter {
     capture(observation: LoadStrikeIterationObservationV1): boolean;
     flushNow(): void;
     sealAndDrain(): Promise<IterationObservationDeliveryResult>;
+    private completeWithRetries;
     buildWarnings(): IterationObservationGeneratorWarning[];
     private createBatch;
     private createCompletion;

package/dist/types/runtime.d.ts

@@ -2526,6 +2526,7 @@ declare function normalizeRuntimeTrackingPayload(payload: TrackingPayload | null
 declare function readRuntimeTrackingId(payload: TrackingPayload, selector: string): string | null;
 declare function runtimeParseBodyAsObject(body: unknown): Record<string, unknown> | null;
 declare function setRuntimeJsonPathValue(body: unknown, path: string, value: string): unknown;
+declare function pickTrackingValue(source: Record<string, unknown>, ...keys: string[]): unknown;
 declare function pickOptionalTrackingSelectorString(source: Record<string, unknown>, key: string, altKey: string): string | undefined;
 declare function pickTrackingNumber(source: Record<string, unknown>, keys: string[], fallback: number): number;
 declare function toTrackingStringMap(value: unknown): Record<string, string>;
@@ -2691,6 +2692,7 @@ export declare const __loadstrikeTestExports: {
     parseStrictBooleanToken: typeof parseStrictBooleanToken;
     percentile: typeof percentile;
     pickOptionalTrackingSelectorString: typeof pickOptionalTrackingSelectorString;
+    pickTrackingValue: typeof pickTrackingValue;
     pickTrackingNumber: typeof pickTrackingNumber;
     produceOrConsumeTrackingPayload: typeof produceOrConsumeTrackingPayload;
     readConfiguredSinkName: typeof readConfiguredSinkName;

package/dist/types/sink-retry-policy.d.ts

@@ -0,0 +1,9 @@
+export declare const DEFAULT_SINK_RETRY_COUNT = 3;
+export declare const DEFAULT_SINK_RETRY_BACKOFF_MS = 250;
+export declare const MAXIMUM_SINK_RETRY_COUNT = 100;
+export declare const MAXIMUM_TIMER_DELAY_MS = 2147483647;
+export declare function normalizeSinkRetryCount(value: number | undefined): number;
+export declare function normalizeSinkRetryBackoffMs(value: number | undefined): number;
+export declare function sinkRetryDelayMs(baseDelayMs: number, retryNumber: number): number;
+export declare function waitForSinkRetryDelay(delayMs: number): Promise<void>;
+export declare function cooperativeSinkRetryYield(): Promise<void>;

package/dist/types/sinks.d.ts

@@ -849,6 +849,9 @@ declare function createRealtimeStatsEvents(session: SinkSessionMetadata, scenari
 declare function createFinalStatsEvents(session: SinkSessionMetadata, stats: LoadStrikeNodeStats): ReportingSinkEvent[];
 declare function createRunResultEvents(session: SinkSessionMetadata, result: LoadStrikeRunResult): ReportingSinkEvent[];
 declare function createReportingEvent(session: SinkSessionMetadata, occurredUtc: Date, eventType: string, scenarioName: string | null, stepName: string | null, tags: Record<string, string>, fields: Record<string, unknown>): ReportingSinkEvent;
+declare function createIterationObservationEvents(session: SinkSessionMetadata, batch: LoadStrikeIterationObservationBatchV1): ReportingSinkEvent[];
+declare function createIterationCompletionEvents(session: SinkSessionMetadata, completion: LoadStrikeIterationObservationStreamCompletionV1): ReportingSinkEvent[];
+declare function portalEventPayload(event: ReportingSinkEvent, index: number): Record<string, unknown>;
 declare function toOtelAnyValue(value: unknown): Record<string, unknown>;
 declare function sinkSessionMetadataFromContext(context: LoadStrikeBaseContext, session?: LoadStrikeSessionStartInfo, options?: {
     distinctRunIdFallback?: boolean;
@@ -897,6 +900,8 @@ export declare const __loadstrikeTestExports: {
     cloneScenarioStats: typeof cloneScenarioStats;
     cloneSessionStartInfo: typeof cloneSessionStartInfo;
     createFinalStatsEvents: typeof createFinalStatsEvents;
+    createIterationCompletionEvents: typeof createIterationCompletionEvents;
+    createIterationObservationEvents: typeof createIterationObservationEvents;
     createRealtimeStatsEvents: typeof createRealtimeStatsEvents;
     createRunResultEvents: typeof createRunResultEvents;
     createReportingEvent: typeof createReportingEvent;
@@ -913,6 +918,7 @@ export declare const __loadstrikeTestExports: {
     normalizeStringMap: typeof normalizeStringMap;
     optionNumber: typeof optionNumber;
     optionString: typeof optionString;
+    portalEventPayload: typeof portalEventPayload;
     pickBooleanValue: typeof pickBooleanValue;
     pickRecordValue: typeof pickRecordValue;
     postWithTimeout: typeof postWithTimeout;

package/dist/types/transports.d.ts

@@ -1072,6 +1072,8 @@ declare function validateTrackingSelectorPath(expression: string, fieldName: "Tr
 declare function validateHttpEndpoint(endpoint: EndpointDefinition, mode: EndpointMode, hasModeDelegate: boolean): void;
 declare function applyHttpAuthHeaders(headers: Record<string, string>, options: HttpEndpointOptions, resolveOAuthToken: () => Promise<string>): Promise<void>;
 declare function buildHttpRequestBody(body: unknown, bodyType: NonNullable<HttpEndpointOptions["bodyType"]>, contentType: string): unknown;
+declare function extractJsonPath(value: unknown, arrayPath?: string): unknown;
+declare function headersToRecord(value: Headers): Record<string, string>;
 declare function partitionFromKey(value: string, partitionCount: number): string;
 declare function attachPayloadHelpers(payload: TrackingPayload): TrackingPayload;
 declare function attachDotNetTrackingPayloadAliases<T extends TrackingPayload>(payload: T): T;
@@ -1142,8 +1144,10 @@ export declare const __loadstrikeTestExports: {
     createNatsHeaders: typeof createNatsHeaders;
     createRedisStreamPayload: typeof createRedisStreamPayload;
     deserializeBrokerPayloadBody: typeof deserializeBrokerPayloadBody;
+    extractJsonPath: typeof extractJsonPath;
     extractTrackingValue: typeof extractTrackingValue;
     fromKafkaHeaders: typeof fromKafkaHeaders;
+    headersToRecord: typeof headersToRecord;
     headerValue: typeof headerValue;
     attachDotNetTrackingPayloadAliases: typeof attachDotNetTrackingPayloadAliases;
     attachPayloadHelpers: typeof attachPayloadHelpers;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loadstrike/loadstrike-sdk",
-  "version": "1.0.30401",
+  "version": "1.0.31001",
   "description": "TypeScript and JavaScript SDK for in-process load execution, traffic correlation, and reporting.",
   "keywords": [
     "load-testing",
@@ -81,7 +81,7 @@
     "typescript": "^5.9.2"
   },
   "overrides": {
-    "brace-expansion": "5.0.7",
+    "brace-expansion": "5.0.8",
     "tar": "7.5.21"
   }
 }