@loadstrike/loadstrike-sdk 1.0.22801 → 1.0.23201

package/dist/esm/index.js

@@ -2,5 +2,5 @@ export { LoadStrikeAutopilot, LoadStrikeAutopilotResult } from "./autopilot.js";
 export { LoadStrikeAutopilotReadiness } from "./autopilot-contracts.js";
 export { CrossPlatformScenarioConfigurator, ScenarioTrackingExtensions, LoadStrikeContext, LoadStrikePluginData, LoadStrikePluginDataTable, LoadStrikeNodeType, LoadStrikeReportFormat, LoadStrikeResponse, LoadStrikeLogLevel, LoadStrikeScenarioOperation, LoadStrikeOperationType, LoadStrikeRunner, LoadStrikeScenario, LoadStrikeSimulation, CrossPlatformTrackingConfiguration, LoadStrikeMetric, LoadStrikeCounter, LoadStrikeGauge, LoadStrikeStep, LoadStrikeThreshold } from "./runtime.js";
 export { CorrelationStoreConfiguration, CrossPlatformTrackingRuntime, InMemoryCorrelationStore, RedisCorrelationStoreOptions, RedisCorrelationStore, TrackingPayloadBuilder, TrackingFieldSelector } from "./correlation.js";
-export { EndpointAdapterFactory, LOADSTRIKE_TRACE_ID_HEADER, LOADSTRIKE_TRACE_ID_TRACKING_FIELD, TrafficEndpointDefinition, HttpEndpointDefinition, KafkaEndpointDefinition, KafkaSaslOptions, RabbitMqEndpointDefinition, NatsEndpointDefinition, RedisStreamsEndpointDefinition, AzureEventHubsEndpointDefinition, DelegateStreamEndpointDefinition, PushDiffusionEndpointDefinition, HttpOAuth2ClientCredentialsOptions, HttpAuthOptions } from "./transports.js";
-export { DatadogReportingSink, DatadogReportingSinkOptions, GrafanaLokiReportingSink, GrafanaLokiReportingSinkOptions, InfluxDbReportingSink, InfluxDbReportingSinkOptions, OtelCollectorReportingSink, OtelCollectorReportingSinkOptions, SplunkReportingSink, SplunkReportingSinkOptions, TimescaleDbReportingSink, TimescaleDbReportingSinkOptions } from "./sinks.js";
+export { LOADSTRIKE_TRACE_ID_HEADER, LOADSTRIKE_TRACE_ID_TRACKING_FIELD, TrafficEndpointDefinition, HttpEndpointDefinition, KafkaEndpointDefinition, KafkaSaslOptions, RabbitMqEndpointDefinition, NatsEndpointDefinition, RedisStreamsEndpointDefinition, AzureEventHubsEndpointDefinition, SqsEndpointDefinition, DelegateStreamEndpointDefinition, PushDiffusionEndpointDefinition, HttpOAuth2ClientCredentialsOptions, HttpAuthOptions } from "./transports.js";
+export { DatadogReportingSink, DatadogReportingSinkOptions, GrafanaLokiReportingSink, GrafanaLokiReportingSinkOptions, InfluxDbReportingSink, InfluxDbReportingSinkOptions, OtelCollectorReportingSink, OtelCollectorReportingSinkOptions, PortalReportingSink, SplunkReportingSink, SplunkReportingSinkOptions, TimescaleDbReportingSink, TimescaleDbReportingSinkOptions } from "./sinks.js";

package/dist/esm/local.js

@@ -5,7 +5,6 @@ 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";
 const DEFAULT_LICENSING_API_BASE_URL = "https://licensing.loadstrike.com";
-const INTERNAL_BLACKBOX_LICENSING_API_BASE_URL_ENVIRONMENT_VARIABLE = "LOADSTRIKE_INTERNAL_BLACKBOX_API_BASE_URL";
 let developmentLicensingApiBaseUrlOverride;
 const BUILT_IN_WORKER_PLUGIN_NAMES = new Set([
     "loadstrike failed responses",
@@ -17,7 +16,8 @@ const SINK_FEATURE_BY_KIND = {
     grafanaloki: "extensions.reporting_sinks.grafana_loki",
     datadog: "extensions.reporting_sinks.datadog",
     splunk: "extensions.reporting_sinks.splunk",
-    otelcollector: "extensions.reporting_sinks.otel_collector"
+    otelcollector: "extensions.reporting_sinks.otel_collector",
+    portal: "extensions.reporting_sinks.portal"
 };
 const TRACKING_FEATURE_BY_KIND = {
     http: "endpoint.http",
@@ -27,7 +27,8 @@ const TRACKING_FEATURE_BY_KIND = {
     pushdiffusion: "endpoint.push_diffusion",
     delegatestream: "endpoint.delegate_stream",
     nats: "endpoint.nats",
-    redisstreams: "endpoint.redis_streams"
+    redisstreams: "endpoint.redis_streams",
+    sqs: "endpoint.sqs"
 };
 const CI_ENVIRONMENT_VARIABLES = [
     "GITHUB_ACTIONS",
@@ -57,6 +58,9 @@ export class LoadStrikeLocalClient {
         this.licensingApiBaseUrl = resolveLicensingApiBaseUrl();
         this.licenseValidationTimeoutMs = normalizeTimeoutMs(options.licenseValidationTimeoutMs);
     }
+    portalReportingIngestUrl() {
+        return `${this.licensingApiBaseUrl.replace(/\/+$/, "")}/api/v1/reporting/ingest`;
+    }
     async run(request) {
         const sanitized = sanitizeRequest(request);
         const licenseSession = await this.acquireLicenseLease(sanitized);
@@ -466,25 +470,8 @@ function normalizeLicensingApiBaseUrl(value) {
     const normalized = (value ?? "").trim();
     return normalized || DEFAULT_LICENSING_API_BASE_URL;
 }
-function resolveInternalBlackboxLicensingApiBaseUrlOverride(value) {
-    const normalized = String(value ?? "").trim();
-    if (!normalized) {
-        return undefined;
-    }
-    try {
-        const parsed = new URL(normalized);
-        const host = parsed.hostname.replace(/^\[|\]$/g, "").toLowerCase();
-        if (["http:", "https:"].includes(parsed.protocol) && ["127.0.0.1", "localhost", "::1"].includes(host)) {
-            return normalized.replace(/\/+$/, "");
-        }
-    }
-    catch {
-        return undefined;
-    }
-    return undefined;
-}
 function resolveLicensingApiBaseUrl() {
-    return normalizeLicensingApiBaseUrl(resolveInternalBlackboxLicensingApiBaseUrlOverride(process.env[INTERNAL_BLACKBOX_LICENSING_API_BASE_URL_ENVIRONMENT_VARIABLE]) ?? developmentLicensingApiBaseUrlOverride);
+    return normalizeLicensingApiBaseUrl(developmentLicensingApiBaseUrlOverride);
 }
 function setDevelopmentLicensingApiBaseUrlOverride(value) {
     developmentLicensingApiBaseUrlOverride = value;
@@ -523,6 +510,9 @@ function collectRequestedFeatures(request) {
     if (countCustomWorkerPlugins(context) > 0) {
         features.add("extensions.worker_plugins.custom");
     }
+    if (asList(pickValue(context, "RuntimePolicies", "runtimePolicies")).length > 0) {
+        features.add("policy.runtime_controls");
+    }
     const reportingSinks = asList(pickValue(context, "ReportingSinks", "reportingSinks"));
     let hasCustomSink = false;
     for (const sink of reportingSinks) {
@@ -818,159 +808,171 @@ async function evaluateScenarioOutcome(scenario, requestCount, context) {
     validateTrackingConfiguration(tracking, sourceEndpoint, destinationEndpoint);
     const sourceAdapter = EndpointAdapterFactory.create(sourceEndpoint);
     const destinationAdapter = destinationEndpoint ? EndpointAdapterFactory.create(destinationEndpoint) : null;
-    const correlationTimeoutOverride = pickValue(tracking, "CorrelationTimeoutMs", "correlationTimeoutMs");
-    const correlationTimeoutSeconds = pickValue(tracking, "CorrelationTimeoutSeconds", "correlationTimeoutSeconds", "CorrelationTimeout");
-    const timeoutMs = correlationTimeoutOverride != null && String(correlationTimeoutOverride).trim() !== ""
-        ? asInt(correlationTimeoutOverride)
-        : Math.trunc((correlationTimeoutSeconds == null || String(correlationTimeoutSeconds).trim() === ""
-            ? 30
-            : asNumber(correlationTimeoutSeconds)) * 1000);
-    const timeoutCountsAsFailure = toBoolean(pickValue(tracking, "TimeoutCountsAsFailure", "timeoutCountsAsFailure"), true);
-    const correlationStore = mapCorrelationStore(tracking, buildTrackingRunNamespace(stringOrDefault(pickValue(context, "SessionId", "sessionId"), "session"), stringOrDefault(pickValue(scenario, "Name", "name"), "scenario"), sourceEndpoint.name, destinationEndpoint?.name));
-    const timeoutSweepIntervalOverride = pickValue(tracking, "TimeoutSweepIntervalMs", "timeoutSweepIntervalMs");
-    const timeoutSweepIntervalSeconds = pickValue(tracking, "TimeoutSweepIntervalSeconds", "timeoutSweepIntervalSeconds");
-    const timeoutSweepIntervalMs = timeoutSweepIntervalOverride != null && String(timeoutSweepIntervalOverride).trim() !== ""
-        ? asInt(timeoutSweepIntervalOverride)
-        : Math.trunc((timeoutSweepIntervalSeconds == null || String(timeoutSweepIntervalSeconds).trim() === ""
-            ? 1
-            : asNumber(timeoutSweepIntervalSeconds)) * 1000);
-    const timeoutBatchSizeValue = pickValue(tracking, "TimeoutBatchSize", "timeoutBatchSize");
-    const timeoutBatchSize = timeoutBatchSizeValue == null || String(timeoutBatchSizeValue).trim() === ""
-        ? 200
-        : asInt(timeoutBatchSizeValue);
-    const runtime = new CrossPlatformTrackingRuntime({
-        sourceTrackingField: sourceEndpoint.trackingField,
-        destinationTrackingField: destinationEndpoint?.trackingField,
-        destinationGatherByField: destinationEndpoint?.gatherByField,
-        trackingFieldValueCaseSensitive: toBoolean(pickValue(tracking, "TrackingFieldValueCaseSensitive", "trackingFieldValueCaseSensitive"), true),
-        gatherByFieldValueCaseSensitive: toBoolean(pickValue(tracking, "GatherByFieldValueCaseSensitive", "gatherByFieldValueCaseSensitive"), true),
-        correlationTimeoutMs: timeoutMs,
-        timeoutCountsAsFailure,
-        store: correlationStore ?? undefined
-    });
-    const runMode = stringOrDefault(pickValue(tracking, "RunMode", "runMode"), "GenerateAndCorrelate").trim().toLowerCase();
-    const sourceOnlyMode = !destinationEndpoint;
-    const restartOnFail = toBoolean(pickValue(scenario, "RestartIterationOnFail", "restartIterationOnFail"), false);
-    const restartMaxAttempts = Math.max(asInt(pickValue(context, "RestartIterationMaxAttempts", "restartIterationMaxAttempts")), 0);
-    const maxFailCount = Math.max(asInt(pickValue(scenario, "MaxFailCount", "maxFailCount")), 0);
-    const scenarioCompletionTimeoutSeconds = Math.max(asNumber(pickValue(context, "ScenarioCompletionTimeoutSeconds", "scenarioCompletionTimeoutSeconds")), 0);
-    const scenarioDeadlineMs = scenarioCompletionTimeoutSeconds > 0
-        ? Date.now() + Math.trunc(scenarioCompletionTimeoutSeconds * 1000)
-        : Number.POSITIVE_INFINITY;
-    let okCount = 0;
-    let failCount = 0;
-    let nowMs = Date.now();
-    let processedIterations = 0;
-    let lastSweepAtMs = nowMs;
-    for (let i = 0; i < requestCount; i += 1) {
-        if (Date.now() > scenarioDeadlineMs) {
-            break;
-        }
-        let iterationComplete = false;
-        let attempts = 0;
-        const maxAttempts = 1 + (restartOnFail ? restartMaxAttempts : 0);
-        while (!iterationComplete) {
-            attempts += 1;
+    let correlationStore = null;
+    try {
+        await sourceAdapter.initialize?.();
+        await destinationAdapter?.initialize?.();
+        const correlationTimeoutOverride = pickValue(tracking, "CorrelationTimeoutMs", "correlationTimeoutMs");
+        const correlationTimeoutSeconds = pickValue(tracking, "CorrelationTimeoutSeconds", "correlationTimeoutSeconds", "CorrelationTimeout");
+        const timeoutMs = correlationTimeoutOverride != null && String(correlationTimeoutOverride).trim() !== ""
+            ? asInt(correlationTimeoutOverride)
+            : Math.trunc((correlationTimeoutSeconds == null || String(correlationTimeoutSeconds).trim() === ""
+                ? 30
+                : asNumber(correlationTimeoutSeconds)) * 1000);
+        const timeoutCountsAsFailure = toBoolean(pickValue(tracking, "TimeoutCountsAsFailure", "timeoutCountsAsFailure"), true);
+        correlationStore = mapCorrelationStore(tracking, buildTrackingRunNamespace(stringOrDefault(pickValue(context, "SessionId", "sessionId"), "session"), stringOrDefault(pickValue(scenario, "Name", "name"), "scenario"), sourceEndpoint.name, destinationEndpoint?.name));
+        const timeoutSweepIntervalOverride = pickValue(tracking, "TimeoutSweepIntervalMs", "timeoutSweepIntervalMs");
+        const timeoutSweepIntervalSeconds = pickValue(tracking, "TimeoutSweepIntervalSeconds", "timeoutSweepIntervalSeconds");
+        const timeoutSweepIntervalMs = timeoutSweepIntervalOverride != null && String(timeoutSweepIntervalOverride).trim() !== ""
+            ? asInt(timeoutSweepIntervalOverride)
+            : Math.trunc((timeoutSweepIntervalSeconds == null || String(timeoutSweepIntervalSeconds).trim() === ""
+                ? 1
+                : asNumber(timeoutSweepIntervalSeconds)) * 1000);
+        const timeoutBatchSizeValue = pickValue(tracking, "TimeoutBatchSize", "timeoutBatchSize");
+        const timeoutBatchSize = timeoutBatchSizeValue == null || String(timeoutBatchSizeValue).trim() === ""
+            ? 200
+            : asInt(timeoutBatchSizeValue);
+        const runtime = new CrossPlatformTrackingRuntime({
+            sourceTrackingField: sourceEndpoint.trackingField,
+            destinationTrackingField: destinationEndpoint?.trackingField,
+            destinationGatherByField: destinationEndpoint?.gatherByField,
+            trackingFieldValueCaseSensitive: toBoolean(pickValue(tracking, "TrackingFieldValueCaseSensitive", "trackingFieldValueCaseSensitive"), true),
+            gatherByFieldValueCaseSensitive: toBoolean(pickValue(tracking, "GatherByFieldValueCaseSensitive", "gatherByFieldValueCaseSensitive"), true),
+            correlationTimeoutMs: timeoutMs,
+            timeoutCountsAsFailure,
+            store: correlationStore ?? undefined
+        });
+        const runMode = stringOrDefault(pickValue(tracking, "RunMode", "runMode"), "GenerateAndCorrelate").trim().toLowerCase();
+        const sourceOnlyMode = !destinationEndpoint;
+        const restartOnFail = toBoolean(pickValue(scenario, "RestartIterationOnFail", "restartIterationOnFail"), false);
+        const restartMaxAttempts = Math.max(asInt(pickValue(context, "RestartIterationMaxAttempts", "restartIterationMaxAttempts")), 0);
+        const maxFailCount = Math.max(asInt(pickValue(scenario, "MaxFailCount", "maxFailCount")), 0);
+        const scenarioCompletionTimeoutSeconds = Math.max(asNumber(pickValue(context, "ScenarioCompletionTimeoutSeconds", "scenarioCompletionTimeoutSeconds")), 0);
+        const scenarioDeadlineMs = scenarioCompletionTimeoutSeconds > 0
+            ? Date.now() + Math.trunc(scenarioCompletionTimeoutSeconds * 1000)
+            : Number.POSITIVE_INFINITY;
+        let okCount = 0;
+        let failCount = 0;
+        let nowMs = Date.now();
+        let processedIterations = 0;
+        let lastSweepAtMs = nowMs;
+        for (let i = 0; i < requestCount; i += 1) {
             if (Date.now() > scenarioDeadlineMs) {
-                iterationComplete = true;
                 break;
             }
-            let sourcePayload = runMode === "correlateexistingtraffic"
-                ? await sourceAdapter.consume()
-                : await sourceAdapter.produce();
-            sourcePayload = normalizePayload(sourcePayload, sourceEndpoint, i);
-            const sourceTrackingId = sourceOnlyMode
-                ? readTrackingId(sourcePayload, sourceEndpoint.trackingField)
-                : await runtime.onSourceProduced(sourcePayload, nowMs);
-            if (!sourceTrackingId) {
-                if (restartOnFail && attempts < maxAttempts) {
+            let iterationComplete = false;
+            let attempts = 0;
+            const maxAttempts = 1 + (restartOnFail ? restartMaxAttempts : 0);
+            while (!iterationComplete) {
+                attempts += 1;
+                if (Date.now() > scenarioDeadlineMs) {
+                    iterationComplete = true;
+                    break;
+                }
+                let sourcePayload = runMode === "correlateexistingtraffic"
+                    ? await sourceAdapter.consume()
+                    : await sourceAdapter.produce();
+                sourcePayload = normalizePayload(sourcePayload, sourceEndpoint, i);
+                const sourceTrackingId = sourceOnlyMode
+                    ? readTrackingId(sourcePayload, sourceEndpoint.trackingField)
+                    : await runtime.onSourceProduced(sourcePayload, nowMs);
+                if (!sourceTrackingId) {
+                    if (restartOnFail && attempts < maxAttempts) {
+                        nowMs += 1;
+                        continue;
+                    }
+                    failCount += 1;
+                    iterationComplete = true;
                     nowMs += 1;
-                    continue;
+                    break;
                 }
-                failCount += 1;
-                iterationComplete = true;
-                nowMs += 1;
-                break;
-            }
-            if (sourceOnlyMode || !destinationAdapter || !destinationEndpoint) {
-                okCount += 1;
-                iterationComplete = true;
-                nowMs += 1;
-                break;
-            }
-            let destinationPayload = await destinationAdapter.consume();
-            destinationPayload = normalizePayload(destinationPayload, destinationEndpoint, i);
-            let matched = await runtime.onDestinationConsumed(destinationPayload, nowMs + 1);
-            const correlationDeadlineMs = nowMs + timeoutMs;
-            while (!matched && Date.now() <= scenarioDeadlineMs && nowMs < correlationDeadlineMs) {
-                const remainingTimeoutMs = correlationDeadlineMs - nowMs;
-                if (remainingTimeoutMs <= 0) {
+                if (sourceOnlyMode || !destinationAdapter || !destinationEndpoint) {
+                    okCount += 1;
+                    iterationComplete = true;
+                    nowMs += 1;
                     break;
                 }
-                await sleep(Math.min(destinationEndpoint.pollIntervalMs ?? 250, remainingTimeoutMs));
-                destinationPayload = normalizePayload(await destinationAdapter.consume(), destinationEndpoint, i);
-                matched = await runtime.onDestinationConsumed(destinationPayload, nowMs + 1);
+                let destinationPayload = await destinationAdapter.consume();
+                destinationPayload = normalizePayload(destinationPayload, destinationEndpoint, i);
+                let matched = await runtime.onDestinationConsumed(destinationPayload, nowMs + 1);
+                const correlationDeadlineMs = nowMs + timeoutMs;
+                while (!matched && Date.now() <= scenarioDeadlineMs && nowMs < correlationDeadlineMs) {
+                    const remainingTimeoutMs = correlationDeadlineMs - nowMs;
+                    if (remainingTimeoutMs <= 0) {
+                        break;
+                    }
+                    await sleep(Math.min(destinationEndpoint.pollIntervalMs ?? 250, remainingTimeoutMs));
+                    destinationPayload = normalizePayload(await destinationAdapter.consume(), destinationEndpoint, i);
+                    matched = await runtime.onDestinationConsumed(destinationPayload, nowMs + 1);
+                    if (matched) {
+                        break;
+                    }
+                    nowMs += Math.max(destinationEndpoint.pollIntervalMs ?? 250, 1);
+                }
                 if (matched) {
-                    break;
+                    okCount += 1;
+                    iterationComplete = true;
                 }
-                nowMs += Math.max(destinationEndpoint.pollIntervalMs ?? 250, 1);
-            }
-            if (matched) {
-                okCount += 1;
-                iterationComplete = true;
-            }
-            else if (restartOnFail && attempts < maxAttempts) {
-                nowMs += 2;
-                continue;
-            }
-            else {
-                await runtime.sweepTimeouts(nowMs + timeoutMs + 1, timeoutBatchSize || undefined);
-                failCount += 1;
-                iterationComplete = true;
-            }
-            nowMs += 2;
-        }
-        processedIterations += 1;
-        if (timeoutSweepIntervalMs > 0 && nowMs - lastSweepAtMs >= timeoutSweepIntervalMs) {
-            const swept = await runtime.sweepTimeouts(nowMs, timeoutBatchSize || undefined);
-            if (swept > 0) {
-                if (timeoutCountsAsFailure) {
-                    failCount += swept;
+                else if (restartOnFail && attempts < maxAttempts) {
+                    nowMs += 2;
+                    continue;
                 }
                 else {
-                    okCount += swept;
+                    await runtime.sweepTimeouts(nowMs + timeoutMs + 1, timeoutBatchSize || undefined);
+                    failCount += 1;
+                    iterationComplete = true;
+                }
+                nowMs += 2;
+            }
+            processedIterations += 1;
+            if (timeoutSweepIntervalMs > 0 && nowMs - lastSweepAtMs >= timeoutSweepIntervalMs) {
+                const swept = await runtime.sweepTimeouts(nowMs, timeoutBatchSize || undefined);
+                if (swept > 0) {
+                    if (timeoutCountsAsFailure) {
+                        failCount += swept;
+                    }
+                    else {
+                        okCount += swept;
+                    }
                 }
+                lastSweepAtMs = nowMs;
+            }
+            if (maxFailCount > 0 && failCount >= maxFailCount) {
+                break;
             }
-            lastSweepAtMs = nowMs;
-        }
-        if (maxFailCount > 0 && failCount >= maxFailCount) {
-            break;
         }
-    }
-    let expired = 0;
-    let sweptChunk = 0;
-    do {
-        sweptChunk = await runtime.sweepTimeouts(nowMs + timeoutMs + 1, timeoutBatchSize || undefined);
-        expired += sweptChunk;
-    } while (timeoutBatchSize > 0 && sweptChunk >= timeoutBatchSize);
-    if (expired > 0) {
-        if (timeoutCountsAsFailure) {
-            failCount += expired;
+        let expired = 0;
+        let sweptChunk = 0;
+        do {
+            sweptChunk = await runtime.sweepTimeouts(nowMs + timeoutMs + 1, timeoutBatchSize || undefined);
+            expired += sweptChunk;
+        } while (timeoutBatchSize > 0 && sweptChunk >= timeoutBatchSize);
+        if (expired > 0) {
+            if (timeoutCountsAsFailure) {
+                failCount += expired;
+            }
+            else {
+                okCount += expired;
+            }
         }
-        else {
-            okCount += expired;
+        if (processedIterations < requestCount && Date.now() > scenarioDeadlineMs) {
+            const timedOutIterations = requestCount - processedIterations;
+            if (timeoutCountsAsFailure) {
+                failCount += timedOutIterations;
+            }
+            else {
+                okCount += timedOutIterations;
+            }
         }
+        return { requestCount: processedIterations, okCount, failCount };
     }
-    if (processedIterations < requestCount && Date.now() > scenarioDeadlineMs) {
-        const timedOutIterations = requestCount - processedIterations;
-        if (timeoutCountsAsFailure) {
-            failCount += timedOutIterations;
-        }
-        else {
-            okCount += timedOutIterations;
-        }
+    finally {
+        await Promise.allSettled([
+            sourceAdapter.dispose?.(),
+            destinationAdapter?.dispose?.(),
+            correlationStore?.close?.()
+        ].filter((value) => Boolean(value)));
     }
-    return { requestCount: processedIterations, okCount, failCount };
 }
 function validateTrackingConfiguration(tracking, sourceEndpoint, destinationEndpoint) {
     if (sourceEndpoint.gatherByField?.trim()) {

package/dist/esm/runtime.js

@@ -7,6 +7,7 @@ import { DistributedClusterAgent, DistributedClusterCoordinator } from "./cluste
 import { CorrelationStoreConfiguration, CrossPlatformTrackingRuntime, RedisCorrelationStore, RedisCorrelationStoreOptions, TrackingFieldSelector } from "./correlation.js";
 import { EndpointAdapterFactory, LOADSTRIKE_TRACE_ID_TRACKING_FIELD } from "./transports.js";
 import { buildDotnetCsvReport, buildDotnetHtmlReport, buildDotnetMarkdownReport, buildDotnetTxtReport } from "./reporting.js";
+import { PortalReportingSink } from "./sinks.js";
 export const LoadStrikeNodeType = {
     SingleNode: "SingleNode",
     Coordinator: "Coordinator",
@@ -1378,6 +1379,16 @@ export class LoadStrikeContext {
         validateNamedReportingSinks(sinks);
         return this.mergeValues({ ReportingSinks: sinks });
     }
+    withPortalReporting() {
+        return this.WithPortalReporting();
+    }
+    WithPortalReporting() {
+        const sinks = [...(this.values.ReportingSinks ?? [])];
+        if (!sinks.some((sink, index) => resolveSinkName(sink, index).trim().toLowerCase() === "portal")) {
+            sinks.push(new PortalReportingSink());
+        }
+        return this.mergeValues({ ReportingSinks: sinks });
+    }
     /**
      * Registers runtime policies for the run.
      * Use this when scenario selection or step execution should obey policy callbacks.
@@ -2118,6 +2129,9 @@ export class LoadStrikeRunner {
     static WithReportingSinks(context, ...sinks) {
         return context.WithReportingSinks(...sinks);
     }
+    static WithPortalReporting(context) {
+        return context.WithPortalReporting();
+    }
     /**
      * Registers runtime policies for the run.
      * Use this when scenario selection or step execution should obey policy callbacks.
@@ -2346,6 +2360,29 @@ export class LoadStrikeRunner {
     WithReportingInterval(intervalSeconds) {
         return this.withReportingInterval(intervalSeconds);
     }
+    withReportingSinks(...sinks) {
+        if (!sinks.length) {
+            throw new Error("At least one reporting sink should be provided.");
+        }
+        if (sinks.some((sink) => sink == null)) {
+            throw new Error("Reporting sink collection cannot contain null values.");
+        }
+        validateNamedReportingSinks(sinks);
+        return this.configure({ reportingSinks: sinks });
+    }
+    WithReportingSinks(...sinks) {
+        return this.withReportingSinks(...sinks);
+    }
+    withPortalReporting() {
+        const sinks = [...(this.options.reportingSinks ?? [])];
+        if (!sinks.some((sink, index) => resolveSinkName(sink, index).trim().toLowerCase() === "portal")) {
+            sinks.push(new PortalReportingSink());
+        }
+        return this.configure({ reportingSinks: sinks });
+    }
+    WithPortalReporting() {
+        return this.withPortalReporting();
+    }
     /**
      * Sets the timeout for cluster command round-trips.
      * Use this when distributed control messages need a tighter or looser deadline.
@@ -2519,6 +2556,7 @@ export class LoadStrikeRunner {
             testInfo,
             getNodeInfo: () => attachNodeInfoAliases({ ...nodeInfo })
         };
+        attachPortalReportingSession(sinkSession, sessionInfo, licenseClient, licenseSession);
         attachSessionStartInfoAliases(sessionInfo);
         nodeInfo.currentOperation = "Init";
         for (const plugin of plugins) {
@@ -4052,10 +4090,23 @@ function attachSessionStartInfoAliases(session) {
     attachAliasMap(session, {
         StartedUtc: "startedUtc",
         ScenarioNames: "scenarioNames",
-        Scenarios: "scenarios"
+        Scenarios: "scenarios",
+        RunToken: "runToken",
+        PortalReportingIngestUrl: "portalReportingIngestUrl"
     });
     return session;
 }
+function attachPortalReportingSession(sinkSession, sessionInfo, licenseClient, licenseSession) {
+    const runToken = stringValueOrDefault(licenseSession?.runToken, "").trim();
+    if (!runToken || !licenseClient) {
+        return;
+    }
+    const ingestUrl = licenseClient.portalReportingIngestUrl();
+    sinkSession.runToken = runToken;
+    sinkSession.portalReportingIngestUrl = ingestUrl;
+    sessionInfo.runToken = runToken;
+    sessionInfo.portalReportingIngestUrl = ingestUrl;
+}
 function attachScenarioInitContextAliases(context) {
     context.nodeInfo = attachNodeInfoAliases(context.nodeInfo);
     context.testInfo = attachTestInfoAliases(context.testInfo);
@@ -6606,6 +6657,7 @@ function mapRuntimeTrackingEndpointSpec(spec, useLoadStrikeTraceIdHeader = false
         nats: asTrackingRecord(pickTrackingValue(spec, "Nats", "nats")),
         redisStreams: asTrackingRecord(pickTrackingValue(spec, "RedisStreams", "redisStreams")),
         azureEventHubs: asTrackingRecord(pickTrackingValue(spec, "AzureEventHubs", "azureEventHubs")),
+        sqs: asTrackingRecord(pickTrackingValue(spec, "Sqs", "sqs")),
         pushDiffusion: asTrackingRecord(pickTrackingValue(spec, "PushDiffusion", "pushDiffusion")),
         delegate: typeof delegateProduce === "function"
             || typeof delegateConsume === "function"