@loadstrike/loadstrike-sdk 1.0.22601 → 1.0.23001

package/dist/esm/autopilot.js

@@ -12,11 +12,13 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 var _LoadStrikeAutopilotResult_httpRequest;
 import fs from "node:fs";
 import { LoadStrikeResponse, LoadStrikeScenario, LoadStrikeSimulation, LoadStrikeThreshold } from "./runtime.js";
+import { LoadStrikeLocalClient } from "./local.js";
 import { LoadStrikeAutopilotReadiness } from "./autopilot-contracts.js";
 const REDACTED = "[REDACTED]";
 const ENV_MARKER_PREFIX = "${LOADSTRIKE_ENV:";
 const ENV_MARKER_SUFFIX = "}";
 const TRACE_TO_TEST_AUTOPILOT_FEATURE = "autopilot.trace_to_test";
+let autopilotLicenseValidationBypassForTests = false;
 const SECRET_KEYS = new Set([
     "authorization",
     "proxy_authorization",
@@ -88,9 +90,10 @@ export class LoadStrikeAutopilotResult {
 }
 _LoadStrikeAutopilotResult_httpRequest = new WeakMap();
 export class LoadStrikeAutopilot {
-    static generate(request) {
+    static async generate(request) {
         const artifact = loadAutopilotArtifact(request);
         const options = request.Options ?? {};
+        await validateGenerationEntitlement(options);
         const result = inferAutopilotResult(artifact, options);
         if (options.IncludePreviewReport) {
             result.PreviewReport = buildPreviewReport(result);
@@ -101,6 +104,57 @@ export class LoadStrikeAutopilot {
         return LoadStrikeAutopilot.generate(request);
     }
 }
+export const __private = {
+    setAutopilotLicenseValidationBypassForTests(value) {
+        autopilotLicenseValidationBypassForTests = value;
+    }
+};
+async function validateGenerationEntitlement(options) {
+    if (autopilotLicenseValidationBypassForTests) {
+        return;
+    }
+    const licensePayload = {
+        Context: {
+            RunnerKey: options.RunnerKey ?? "",
+            LicenseValidationTimeoutSeconds: options.LicenseValidationTimeoutSeconds,
+            TestSuite: "loadstrike-autopilot",
+            TestName: options.ScenarioName?.trim() || "autopilot-generation"
+        },
+        Scenarios: [
+            {
+                Name: "autopilot-generation",
+                InternalLicenseFeatures: [TRACE_TO_TEST_AUTOPILOT_FEATURE]
+            }
+        ],
+        RunArgs: []
+    };
+    const client = new LoadStrikeLocalClient({
+        licenseValidationTimeoutMs: normalizeLicenseValidationTimeoutMs(options.LicenseValidationTimeoutSeconds)
+    });
+    let session;
+    try {
+        session = await client.acquireLicenseLease(licensePayload);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (message.toLowerCase().includes("runner key is required")) {
+            throw new Error("Runner key is required for Trace-To-Test Autopilot generation. " +
+                "Set Options.RunnerKey before calling LoadStrikeAutopilot.generate(...).");
+        }
+        throw error;
+    }
+    finally {
+        if (session) {
+            await client.releaseLicenseLease(session, licensePayload);
+        }
+    }
+}
+function normalizeLicenseValidationTimeoutMs(value) {
+    if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+        return undefined;
+    }
+    return Math.trunc(value * 1000);
+}
 function loadAutopilotArtifact(request) {
     if (!request || typeof request.Kind !== "string" || !request.Kind.trim()) {
         throw new Error("Autopilot kind must be provided.");

package/dist/esm/index.js

@@ -1,6 +1,6 @@
 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, LoadStrikeMetric, LoadStrikeCounter, LoadStrikeGauge, LoadStrikeStep, LoadStrikeThreshold } from "./runtime.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 { 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, 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",
@@ -27,7 +26,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",
@@ -466,25 +466,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 +506,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 +804,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()) {
@@ -1007,10 +1005,20 @@ function validateTrackingConfiguration(tracking, sourceEndpoint, destinationEndp
     if (!metricPrefix.trim()) {
         throw new Error("MetricPrefix must be provided.");
     }
+    const observationDurationOverride = pickValue(tracking, "ObservationDurationMs", "observationDurationMs");
+    const observationDurationSeconds = pickValue(tracking, "ObservationDurationSeconds", "observationDurationSeconds", "ObservationDuration");
+    const observationDurationMs = observationDurationOverride != null && String(observationDurationOverride).trim() !== ""
+        ? asNumber(observationDurationOverride)
+        : (observationDurationSeconds == null || String(observationDurationSeconds).trim() === ""
+            ? 0
+            : asNumber(observationDurationSeconds) * 1000);
     validateRedisCorrelationStoreConfiguration(tracking);
     const runModeRaw = stringOrDefault(pickValue(tracking, "RunMode", "runMode"), "GenerateAndCorrelate").trim().toLowerCase();
     const runMode = runModeRaw === "sourceonly" ? "generateandcorrelate" : runModeRaw;
     if (runMode === "generateandcorrelate") {
+        if (observationDurationMs > 0) {
+            throw new Error("ForDuration is only supported for CorrelateExistingTraffic.");
+        }
         if (sourceEndpoint.mode !== "Produce") {
             throw new Error("Source endpoint mode must be Produce for GenerateAndCorrelate mode.");
         }
@@ -1020,6 +1028,9 @@ function validateTrackingConfiguration(tracking, sourceEndpoint, destinationEndp
         return;
     }
     if (runMode === "correlateexistingtraffic") {
+        if (observationDurationMs <= 0) {
+            throw new Error("CorrelateExistingTraffic requires ForDuration with a duration greater than zero.");
+        }
         if (!destinationEndpoint) {
             throw new Error("Destination endpoint must be provided for CorrelateExistingTraffic mode.");
         }