@loadstrike/loadstrike-sdk 1.0.31001 → 1.0.32601

package/dist/esm/local.js

@@ -15,10 +15,9 @@ import * as fs from "node:fs";
 import * as childProcess from "node:child_process";
 import { createHash, createVerify, randomUUID } from "node:crypto";
 import { CorrelationStoreConfiguration, CrossPlatformTrackingRuntime, RedisCorrelationStoreOptions, RedisCorrelationStore, TrackingFieldSelector } from "./correlation.js";
-import { EndpointAdapterFactory, LOADSTRIKE_TRACE_ID_TRACKING_FIELD } from "./transports.js";
-import { BLACKBOX_LICENSING_API_BASE_URL_TOKEN } from "./internal-build.js";
+import { EndpointAdapterFactory, LOADSTRIKE_TRACE_ID_TRACKING_FIELD, validateNativeEndpointExecutionSupport } from "./transports.js";
+import { assertNoUnsupportedReportingInfraConfig, assertNoUnsupportedReportingSinkGraph } from "./reporting-containment.js";
 const DEFAULT_LICENSING_API_BASE_URL = "https://licensing.loadstrike.com";
-let developmentLicensingApiBaseUrlOverride;
 const BUILT_IN_WORKER_PLUGIN_NAMES = new Set([
     "loadstrike failed responses",
     "loadstrike correlation"
@@ -72,7 +71,7 @@ export class LoadStrikeLocalClient {
         _LoadStrikeLocalClient_signingKeyCache.set(this, new Map());
         _LoadStrikeLocalClient_heartbeatDrains.set(this, new WeakMap());
         assertNoDisableLicenseEnforcementOption(options, "LoadStrikeLocalClient");
-        __classPrivateFieldSet(this, _LoadStrikeLocalClient_licensingApiBaseUrl, resolveLicensingApiBaseUrl(), "f");
+        __classPrivateFieldSet(this, _LoadStrikeLocalClient_licensingApiBaseUrl, DEFAULT_LICENSING_API_BASE_URL, "f");
         this.licenseValidationTimeoutMs = normalizeTimeoutMs(options.licenseValidationTimeoutMs);
     }
     portalReportingIngestUrl() {
@@ -80,6 +79,7 @@ export class LoadStrikeLocalClient {
     }
     async run(request) {
         const sanitized = sanitizeRequest(request);
+        validateContainmentRequest(sanitized);
         const licenseSession = await this.acquireLicenseLease(sanitized);
         try {
             const createdUtc = new Date();
@@ -534,66 +534,27 @@ function sanitizeRequest(request) {
         RunArgs: runArgs
     };
 }
-function normalizeLicensingApiBaseUrl(value) {
-    const normalized = (value ?? "").trim();
-    return normalized || DEFAULT_LICENSING_API_BASE_URL;
-}
-function resolveLicensingApiBaseUrl() {
-    return normalizeLicensingApiBaseUrl(developmentLicensingApiBaseUrlOverride ?? resolveInternalBlackBoxLicensingApiBaseUrl());
-}
-function setDevelopmentLicensingApiBaseUrlOverride(value) {
-    if (value != null && value.trim()) {
-        assertInternalTestHarnessLicensingOverride();
-        const normalized = normalizeLicensingApiBaseUrl(value);
-        if (!isLoopbackHttpBaseUrl(normalized)) {
-            throw new TypeError("Internal development licensing API overrides must use a loopback http URL.");
+function validateContainmentRequest(request) {
+    const scenarios = Array.isArray(request.Scenarios) ? request.Scenarios : [];
+    for (const scenarioValue of scenarios) {
+        const scenario = asRecord(scenarioValue);
+        const tracking = asRecord(pickValue(scenario, "Tracking", "tracking"));
+        for (const field of ["Source", "Destination"]) {
+            const endpoint = asRecord(pickValue(tracking, field, field.toLowerCase()));
+            if (Object.keys(endpoint).length > 0) {
+                validateNativeEndpointExecutionSupport(endpoint);
+            }
         }
-        developmentLicensingApiBaseUrlOverride = normalized;
-        return;
-    }
-    if (value != null) {
-        assertInternalTestHarnessLicensingOverride();
-    }
-    developmentLicensingApiBaseUrlOverride = undefined;
-}
-function assertInternalTestHarnessLicensingOverride() {
-    if (isInternalTestHarnessCall()) {
-        return;
-    }
-    throw new TypeError("Internal development licensing API override is available only to LoadStrike SDK tests.");
-}
-function isInternalTestHarnessCall() {
-    const stack = String(new Error().stack ?? "").replace(/\\/g, "/").toLowerCase();
-    return stack.includes("/sdk/ts/tests/");
-}
-function isLoopbackHttpBaseUrl(value) {
-    let parsed;
-    try {
-        parsed = new URL(value);
-    }
-    catch {
-        return false;
-    }
-    if (parsed.protocol !== "http:") {
-        return false;
     }
-    const host = parsed.hostname.trim().toLowerCase();
-    return host === "localhost" || host === "127.0.0.1" || host === "[::1]" || host === "::1" || host.endsWith(".localhost");
-}
-function resolveInternalBlackBoxLicensingApiBaseUrl() {
-    const compiledToken = String(BLACKBOX_LICENSING_API_BASE_URL_TOKEN ?? "").trim();
-    if (!compiledToken) {
-        return undefined;
-    }
-    const envToken = String(process.env.LOADSTRIKE_INTERNAL_BLACKBOX_API_BASE_URL_TOKEN ?? "").trim();
-    if (!envToken || envToken !== compiledToken) {
-        return undefined;
-    }
-    const candidate = normalizeLicensingApiBaseUrl(process.env.LOADSTRIKE_INTERNAL_BLACKBOX_API_BASE_URL);
-    if (!isLoopbackHttpBaseUrl(candidate)) {
-        return undefined;
+    const context = asRecord(request.Context);
+    const reportingSinks = asList(pickValue(context, "ReportingSinks", "reportingSinks"));
+    for (const [key, value] of Object.entries(context)) {
+        const normalizedKey = key.trim().toLowerCase().replace(/[^a-z0-9]+/g, "");
+        if (normalizedKey === "infraconfig") {
+            assertNoUnsupportedReportingInfraConfig(value, reportingSinks);
+        }
     }
-    return candidate;
+    assertNoUnsupportedReportingSinkGraph(reportingSinks);
 }
 function normalizeTimeoutMs(value) {
     if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
@@ -1301,6 +1262,20 @@ function mapEndpointSpec(spec, useLoadStrikeTraceIdHeader = false) {
         redisStreams: asRecord(pickValue(spec, "RedisStreams", "redisStreams")),
         azureEventHubs: asRecord(pickValue(spec, "AzureEventHubs", "azureEventHubs")),
         pushDiffusion: asRecord(pickValue(spec, "PushDiffusion", "pushDiffusion")),
+        grpc: mapEndpointProtocolOptions(spec, ["Grpc", "grpc"], [
+            "Target", "target", "ServiceName", "serviceName", "MethodName", "methodName",
+            "MethodType", "methodType", "Deadline", "deadline", "DeadlineSeconds", "deadlineSeconds",
+            "DeadlineMs", "deadlineMs", "Metadata", "metadata", "Produce", "produce", "Consume", "consume",
+            "ProduceAsync", "produceAsync", "ConsumeAsync", "consumeAsync", "ConnectionMetadata", "connectionMetadata",
+            "NativeClient", "nativeClient"
+        ]),
+        webSocket: mapEndpointProtocolOptions(spec, ["WebSocket", "webSocket"], [
+            "Url", "url", "Subprotocols", "subprotocols", "ConnectTimeout", "connectTimeout",
+            "ConnectTimeoutSeconds", "connectTimeoutSeconds", "ConnectTimeoutMs", "connectTimeoutMs",
+            "CloseTimeout", "closeTimeout", "CloseTimeoutSeconds", "closeTimeoutSeconds", "CloseTimeoutMs", "closeTimeoutMs",
+            "Produce", "produce", "Consume", "consume", "ProduceAsync", "produceAsync", "ConsumeAsync", "consumeAsync",
+            "ConnectionMetadata", "connectionMetadata", "NativeClient", "nativeClient"
+        ]),
         delegate: (typeof delegateProduce === "function"
             || typeof delegateConsume === "function"
             || typeof delegateProduceAsync === "function"
@@ -1323,6 +1298,19 @@ function mapEndpointSpec(spec, useLoadStrikeTraceIdHeader = false) {
             : undefined
     };
 }
+function mapEndpointProtocolOptions(spec, nestedKeys, flatKeys) {
+    const nested = asRecord(pickValue(spec, ...nestedKeys));
+    if (Object.keys(nested).length > 0) {
+        return nested;
+    }
+    const options = {};
+    for (const key of flatKeys) {
+        if (Object.prototype.hasOwnProperty.call(spec, key)) {
+            options[key] = spec[key];
+        }
+    }
+    return options;
+}
 function normalizePayload(payload, endpoint, index) {
     const resolvedBody = payload?.body ?? endpoint.messagePayload;
     const normalized = {
@@ -2279,8 +2267,6 @@ export const __loadstrikeTestExports = {
     mapEnvironmentClassification,
     mapEndpointSpec,
     normalizeEndpointPayloadValue,
-    normalizeLicensingApiBaseUrl,
-    resolveLicensingApiBaseUrl,
     normalizeNodeType,
     normalizePayload,
     normalizeStringArray,
@@ -2299,7 +2285,6 @@ export const __loadstrikeTestExports = {
     sanitizeLooseJson,
     sanitizeRequest,
     setJsonPathValue,
-    setDevelopmentLicensingApiBaseUrlOverride,
     sleep,
     stringOrDefault,
     toBoolean,

package/dist/esm/report-history.js

@@ -0,0 +1,413 @@
+export const REPORT_HISTORY_MAX_POINTS = 2048;
+export const REPORT_HISTORY_MAX_SCALAR_VALUES = 262144;
+/**
+ * Bounded report-only cumulative telemetry. This type is intentionally not
+ * exported from the package entry point and never participates in public run,
+ * sink, observation, or cluster payloads.
+ */
+export class ReportHistoryCollector {
+    constructor(options) {
+        this.points = [];
+        this.terminalCaptured = false;
+        const scenarioCount = Math.max(1, Math.trunc(options.scenarioCount));
+        const scalarValuesPerPoint = scenarioCount * 16;
+        const budgetPointLimit = Math.floor(REPORT_HISTORY_MAX_SCALAR_VALUES / scalarValuesPerPoint);
+        if (!Number.isSafeInteger(scalarValuesPerPoint) || budgetPointLimit < 2) {
+            this.pointLimit = 0;
+            this.reasonCategory = "budget_pressure";
+        }
+        else {
+            const requestedLimit = options.maxPoints === undefined
+                ? REPORT_HISTORY_MAX_POINTS
+                : Math.max(2, Math.trunc(options.maxPoints));
+            this.pointLimit = Math.min(REPORT_HISTORY_MAX_POINTS, requestedLimit, Math.max(2, budgetPointLimit));
+        }
+        this.nowNs = options.nowNs ?? (() => process.hrtime.bigint());
+        this.onCaptureError = options.onCaptureError;
+    }
+    get available() {
+        return this.reasonCategory === undefined;
+    }
+    start(startNs = this.nowNs()) {
+        if (!this.available || this.startNs !== undefined) {
+            return;
+        }
+        this.startNs = startNs;
+    }
+    capture(snapshotFactory) {
+        return this.captureSafely(snapshotFactory, false);
+    }
+    finalize(snapshotFactory) {
+        return this.captureSafely(snapshotFactory, true);
+    }
+    disable(reasonCategory) {
+        this.reasonCategory = reasonCategory;
+        this.points = [];
+    }
+    toProjection() {
+        if (this.reasonCategory !== undefined) {
+            return {
+                status: "unavailable",
+                reasonCategory: this.reasonCategory,
+                points: []
+            };
+        }
+        return {
+            status: "available",
+            points: this.points.map(clonePoint)
+        };
+    }
+    captureSafely(snapshotFactory, terminal) {
+        if (!this.available || (this.terminalCaptured && !terminal)) {
+            return false;
+        }
+        try {
+            if (this.startNs === undefined) {
+                this.start();
+            }
+            const nowNs = this.nowNs();
+            const elapsedNs = nowNs > this.startNs ? nowNs - this.startNs : 0n;
+            const elapsedSeconds = Number(elapsedNs) / 1000000000;
+            const scenarios = [...snapshotFactory()]
+                .map(projectScenario)
+                .sort((left, right) => (left.sortIndex ?? 0) - (right.sortIndex ?? 0)
+                || left.scenarioName.localeCompare(right.scenarioName));
+            const point = {
+                elapsedSeconds: finiteNonNegative(elapsedSeconds) ?? 0,
+                terminal,
+                scenarios
+            };
+            if (terminal) {
+                this.points = this.points.filter((existing) => existing.elapsedSeconds <= point.elapsedSeconds);
+                this.terminalCaptured = true;
+            }
+            const existingIndex = this.points.findIndex((existing) => existing.elapsedSeconds === point.elapsedSeconds);
+            if (existingIndex >= 0) {
+                if (terminal || !this.points[existingIndex].terminal) {
+                    this.points[existingIndex] = point;
+                }
+            }
+            else if (point.elapsedSeconds > 0 || terminal) {
+                this.points.push(point);
+                this.points.sort((left, right) => left.elapsedSeconds - right.elapsedSeconds);
+            }
+            this.compact();
+            return true;
+        }
+        catch (error) {
+            this.disable("capture_failure");
+            try {
+                this.onCaptureError?.(error);
+            }
+            catch {
+                // Report diagnostics are best-effort and must never affect the run.
+            }
+            return false;
+        }
+    }
+    compact() {
+        if (this.pointLimit === 2 && this.points.length > 2) {
+            this.points = [this.points[0], this.points[this.points.length - 1]];
+            return;
+        }
+        while (this.points.length > this.pointLimit) {
+            const newest = this.points[this.points.length - 1];
+            const thinned = [this.points[0]];
+            for (let index = 1; index < this.points.length - 1; index += 2) {
+                thinned.push(this.points[index]);
+            }
+            if (thinned[thinned.length - 1] !== newest) {
+                thinned.push(newest);
+            }
+            this.points = thinned;
+        }
+    }
+}
+/**
+ * Coordinates one private history worker across every local scenario. The
+ * first measured phase establishes the history clock, and the last scenario
+ * leaving execution records the terminal point before scenario cleanup.
+ */
+export class ReportHistoryLifecycleCoordinator {
+    constructor(worker) {
+        this.worker = worker;
+        this.measuredLoadStarted = false;
+        this.endedScenarios = 0;
+        this.completed = false;
+        this.terminalBoundaryReleased = false;
+        this.scenarioCount = Math.max(1, Math.trunc(worker.scenarioCount ?? 1));
+        this.terminalBoundary = new Promise((resolve) => {
+            this.releaseTerminalBoundary = resolve;
+        });
+    }
+    scenarioBombingStarted() {
+        if (this.completed || this.measuredLoadStarted) {
+            return;
+        }
+        this.measuredLoadStarted = true;
+        try {
+            this.worker.start();
+        }
+        catch {
+            // The private report-only worker cannot fail the measured run.
+        }
+    }
+    async scenarioExecutionEnded() {
+        if (this.completed) {
+            await this.terminalBoundary;
+            return;
+        }
+        this.endedScenarios += 1;
+        if (this.endedScenarios < this.scenarioCount) {
+            await this.terminalBoundary;
+            return;
+        }
+        this.completed = true;
+        try {
+            if (this.measuredLoadStarted) {
+                this.worker.stopAndFinalize();
+            }
+        }
+        catch {
+            // The private report-only worker cannot fail scenario completion.
+        }
+        finally {
+            this.releaseBoundary();
+        }
+        await this.terminalBoundary;
+    }
+    stopWithoutFinalizing() {
+        if (this.completed) {
+            this.releaseBoundary();
+            return;
+        }
+        this.completed = true;
+        try {
+            if (this.measuredLoadStarted) {
+                this.worker.stopWithoutFinalizing();
+            }
+        }
+        catch {
+            // The private report-only worker cannot fail run cleanup.
+        }
+        finally {
+            this.releaseBoundary();
+        }
+    }
+    releaseBoundary() {
+        if (!this.terminalBoundaryReleased) {
+            this.terminalBoundaryReleased = true;
+            this.releaseTerminalBoundary();
+        }
+    }
+}
+/**
+ * Owns the report timer. Every cadence calculation, timeout callback, snapshot,
+ * and projection is exception-bounded so report history can never fail a run.
+ */
+export class ReportHistoryWorker {
+    constructor(options) {
+        this.options = options;
+        this.cadenceNs = 0n;
+        this.nextDeadlineNs = 0n;
+        this.running = false;
+        this.nowNs = options.nowNs ?? (() => process.hrtime.bigint());
+    }
+    get started() {
+        return this.running;
+    }
+    start() {
+        if (this.running || !this.options.collector.available) {
+            return;
+        }
+        try {
+            this.cadenceNs = cadenceNanoseconds(this.options.cadenceSeconds);
+            const nowNs = this.nowNs();
+            this.options.collector.start(nowNs);
+            this.nextDeadlineNs = nowNs + this.cadenceNs;
+            this.running = true;
+            this.scheduleNext();
+        }
+        catch (error) {
+            this.fail(error);
+        }
+    }
+    stopAndFinalize() {
+        if (!this.running) {
+            return;
+        }
+        this.running = false;
+        if (this.timer !== undefined) {
+            clearTimeout(this.timer);
+            this.timer = undefined;
+        }
+        try {
+            this.options.collector.finalize(this.options.snapshotFactory);
+        }
+        catch (error) {
+            this.fail(error);
+        }
+    }
+    stopWithoutFinalizing() {
+        this.running = false;
+        if (this.timer !== undefined) {
+            clearTimeout(this.timer);
+            this.timer = undefined;
+        }
+    }
+    scheduleNext() {
+        try {
+            if (!this.running || !this.options.collector.available) {
+                return;
+            }
+            const remainingNs = this.nextDeadlineNs - this.nowNs();
+            const delayMs = safeTimeoutDelayMs(remainingNs);
+            this.timer = setTimeout(() => this.onTimer(), delayMs);
+            if (typeof this.timer.unref === "function") {
+                this.timer.unref();
+            }
+        }
+        catch (error) {
+            this.fail(error);
+        }
+    }
+    onTimer() {
+        try {
+            this.timer = undefined;
+            if (!this.running || !this.options.collector.available) {
+                return;
+            }
+            const nowNs = this.nowNs();
+            if (nowNs < this.nextDeadlineNs) {
+                this.scheduleNext();
+                return;
+            }
+            this.options.collector.capture(this.options.snapshotFactory);
+            if (!this.options.collector.available) {
+                this.running = false;
+                return;
+            }
+            do {
+                this.nextDeadlineNs += this.cadenceNs;
+            } while (this.nextDeadlineNs <= nowNs);
+            this.scheduleNext();
+        }
+        catch (error) {
+            this.fail(error);
+        }
+    }
+    fail(error) {
+        this.stopWithoutFinalizing();
+        this.options.collector.disable("capture_failure");
+        try {
+            this.options.onFailure?.("capture_failure", sanitizedExceptionClassChain(error));
+        }
+        catch {
+            // Logging a report-only warning is best-effort.
+        }
+    }
+}
+export function sanitizedExceptionClassChain(error) {
+    const classes = [];
+    const seen = new Set();
+    let current = error;
+    while (current !== undefined && current !== null && classes.length < 8 && !seen.has(current)) {
+        seen.add(current);
+        const rawName = typeof current === "object"
+            ? String(current.constructor?.name ?? "Error")
+            : typeof current;
+        const safeName = rawName.replace(/[^A-Za-z0-9_.$-]/g, "_").slice(0, 64) || "Error";
+        classes.push(safeName);
+        current = typeof current === "object"
+            ? current.cause
+            : undefined;
+    }
+    return classes.join(" -> ") || "Error";
+}
+function cadenceNanoseconds(seconds) {
+    if (!Number.isFinite(seconds) || seconds <= 0) {
+        throw new RangeError("Invalid report history cadence.");
+    }
+    const safelyRepresentableSeconds = Math.min(seconds, Number.MAX_SAFE_INTEGER);
+    const wholeSeconds = Math.trunc(safelyRepresentableSeconds);
+    const fractionalNanoseconds = Math.round(Math.max(0, safelyRepresentableSeconds - wholeSeconds) * 1000000000);
+    const cadence = BigInt(wholeSeconds) * 1000000000n + BigInt(fractionalNanoseconds);
+    if (cadence <= 0n) {
+        throw new RangeError("Report history cadence is below one nanosecond.");
+    }
+    return cadence;
+}
+function safeTimeoutDelayMs(remainingNs) {
+    if (remainingNs <= 0n) {
+        return 1;
+    }
+    const milliseconds = (remainingNs + 999999n) / 1000000n;
+    return Number(milliseconds > 2147483647n ? 2147483647n : milliseconds);
+}
+export function deriveScenarioRates(points) {
+    const scenarioNames = [...new Set(points.flatMap((point) => point.scenarios.map((scenario) => scenario.scenarioName)))];
+    return scenarioNames.map((scenarioName) => {
+        let previousElapsed = 0;
+        let previousCount = 0;
+        return {
+            scenarioName,
+            values: points.map((point) => {
+                const scenario = point.scenarios.find((candidate) => candidate.scenarioName === scenarioName);
+                const currentCount = scenario?.all?.count
+                    ?? ((scenario?.ok?.count ?? 0) + (scenario?.failed?.count ?? 0));
+                const duration = point.elapsedSeconds - previousElapsed;
+                const rate = duration > 0
+                    ? Math.max(0, currentCount - previousCount) / duration
+                    : null;
+                previousElapsed = point.elapsedSeconds;
+                previousCount = currentCount;
+                return rate === null || !Number.isFinite(rate) ? null : rate;
+            })
+        };
+    });
+}
+function projectScenario(source) {
+    return {
+        scenarioName: String(source.scenarioName ?? ""),
+        sortIndex: finiteNonNegativeInteger(source.sortIndex),
+        ...(source.all ? { all: projectMeasurement(source.all) } : {}),
+        ...(source.ok ? { ok: projectMeasurement(source.ok) } : {}),
+        ...(source.failed ? { failed: projectMeasurement(source.failed) } : {})
+    };
+}
+function projectMeasurement(source) {
+    return {
+        count: finiteNonNegativeInteger(source.count) ?? 0,
+        bytes: finiteNonNegative(source.bytes) ?? 0,
+        approximate: source.approximate === true,
+        ...optionalFinite("percent50Ms", source.percent50Ms),
+        ...optionalFinite("percent75Ms", source.percent75Ms),
+        ...optionalFinite("percent95Ms", source.percent95Ms),
+        ...optionalFinite("percent99Ms", source.percent99Ms)
+    };
+}
+function optionalFinite(key, value) {
+    const normalized = finiteNonNegative(value);
+    return normalized === undefined ? {} : { [key]: normalized };
+}
+function finiteNonNegative(value) {
+    return typeof value === "number" && Number.isFinite(value) && value >= 0
+        ? value
+        : undefined;
+}
+function finiteNonNegativeInteger(value) {
+    const normalized = finiteNonNegative(value);
+    return normalized === undefined ? undefined : Math.trunc(normalized);
+}
+function clonePoint(point) {
+    return {
+        elapsedSeconds: point.elapsedSeconds,
+        terminal: point.terminal,
+        scenarios: point.scenarios.map((scenario) => ({
+            ...scenario,
+            ...(scenario.all ? { all: { ...scenario.all } } : {}),
+            ...(scenario.ok ? { ok: { ...scenario.ok } } : {}),
+            ...(scenario.failed ? { failed: { ...scenario.failed } } : {})
+        }))
+    };
+}