@loadstrike/loadstrike-sdk 1.0.21401 → 1.0.22301

package/dist/esm/runtime.js

@@ -1,11 +1,11 @@
 import { appendFileSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { randomBytes } from "node:crypto";
+import { randomBytes, randomUUID } from "node:crypto";
 import os from "node:os";
 import { resolve } from "node:path";
 import { LoadStrikeLocalClient } from "./local.js";
 import { DistributedClusterAgent, DistributedClusterCoordinator } from "./cluster.js";
 import { CorrelationStoreConfiguration, CrossPlatformTrackingRuntime, RedisCorrelationStore, RedisCorrelationStoreOptions, TrackingFieldSelector } from "./correlation.js";
-import { EndpointAdapterFactory } from "./transports.js";
+import { EndpointAdapterFactory, LOADSTRIKE_TRACE_ID_TRACKING_FIELD } from "./transports.js";
 import { buildDotnetCsvReport, buildDotnetHtmlReport, buildDotnetMarkdownReport, buildDotnetTxtReport } from "./reporting.js";
 export const LoadStrikeNodeType = {
     SingleNode: "SingleNode",
@@ -1706,9 +1706,10 @@ export class LoadStrikeScenario {
             throw new Error("Tracking source endpoint must be provided.");
         }
         const destinationSpec = asTrackingRecord(pickTrackingValue(copied, "Destination", "destination"));
-        const sourceEndpoint = mapRuntimeTrackingEndpointSpec(sourceSpec);
+        const useLoadStrikeTraceIdHeader = readUseLoadStrikeTraceIdHeader(copied);
+        const sourceEndpoint = mapRuntimeTrackingEndpointSpec(sourceSpec, useLoadStrikeTraceIdHeader);
         const destinationEndpoint = Object.keys(destinationSpec).length
-            ? mapRuntimeTrackingEndpointSpec(destinationSpec)
+            ? mapRuntimeTrackingEndpointSpec(destinationSpec, useLoadStrikeTraceIdHeader)
             : null;
         validateRuntimeTrackingConfiguration(copied, sourceEndpoint, destinationEndpoint);
         return new LoadStrikeScenario(this.name, this.runHandler, this.initHandler, this.cleanHandler, this.loadSimulations, this.thresholds, copied, this.maxFailCount, this.withoutWarmUpValue, this.warmUpDurationSeconds, this.weight, this.restartIterationOnFail, this.internalLicenseFeatures);
@@ -5710,9 +5711,10 @@ class ManagedScenarioTrackingRuntime {
         this.timeoutLoop = null;
         const sourceSpec = asTrackingRecord(pickTrackingValue(tracking, "Source", "source"));
         const destinationSpec = asTrackingRecord(pickTrackingValue(tracking, "Destination", "destination"));
-        this.sourceEndpoint = mapRuntimeTrackingEndpointSpec(sourceSpec);
+        const useLoadStrikeTraceIdHeader = readUseLoadStrikeTraceIdHeader(tracking);
+        this.sourceEndpoint = mapRuntimeTrackingEndpointSpec(sourceSpec, useLoadStrikeTraceIdHeader);
         this.destinationEndpoint = Object.keys(destinationSpec).length
-            ? mapRuntimeTrackingEndpointSpec(destinationSpec)
+            ? mapRuntimeTrackingEndpointSpec(destinationSpec, useLoadStrikeTraceIdHeader)
             : null;
         validateRuntimeTrackingConfiguration(tracking, this.sourceEndpoint, this.destinationEndpoint);
         this.runMode = normalizeTrackingRunMode(pickTrackingString(tracking, "RunMode", "runMode", "GenerateAndCorrelate"));
@@ -6207,9 +6209,12 @@ function getScenarioTrackingRuntime(context, tracking) {
     return lease.runtime;
 }
 function buildTrackingLeaseKey(sessionId, scenarioName, tracking) {
-    const source = mapRuntimeTrackingEndpointSpec(asTrackingRecord(pickTrackingValue(tracking, "Source", "source")));
+    const useLoadStrikeTraceIdHeader = readUseLoadStrikeTraceIdHeader(tracking);
+    const source = mapRuntimeTrackingEndpointSpec(asTrackingRecord(pickTrackingValue(tracking, "Source", "source")), useLoadStrikeTraceIdHeader);
     const destinationSpec = asTrackingRecord(pickTrackingValue(tracking, "Destination", "destination"));
-    const destination = Object.keys(destinationSpec).length ? mapRuntimeTrackingEndpointSpec(destinationSpec) : null;
+    const destination = Object.keys(destinationSpec).length
+        ? mapRuntimeTrackingEndpointSpec(destinationSpec, useLoadStrikeTraceIdHeader)
+        : null;
     const runMode = normalizeTrackingRunMode(pickTrackingString(tracking, "RunMode", "runMode", "GenerateAndCorrelate"));
     return `${sessionId}|${scenarioName}|${source.name}|${destination?.name ?? "<source-only>"}|${runMode}`;
 }
@@ -6289,6 +6294,9 @@ function validateRuntimeTrackingConfiguration(tracking, sourceEndpoint, destinat
     }
     throw new RangeError(`Unsupported tracking run mode: ${runMode}.`);
 }
+function readUseLoadStrikeTraceIdHeader(tracking) {
+    return pickTrackingBoolean(tracking, "UseLoadStrikeTraceIdHeader", "useLoadStrikeTraceIdHeader", false);
+}
 function validateRuntimeRedisCorrelationStoreConfiguration(tracking) {
     const storeSpec = asTrackingRecord(pickTrackingValue(tracking, "CorrelationStore", "correlationStore"));
     const kind = pickTrackingString(storeSpec, "Kind", "kind", "").trim().toLowerCase();
@@ -6372,12 +6380,12 @@ function sanitizeTrackingNamespacePart(value) {
         .replace(/\s+/g, "_");
 }
 async function produceOrConsumeTrackingPayload(adapter, endpoint, runMode, index) {
-    const payload = runMode === "correlateexistingtraffic"
-        ? await adapter.consume()
-        : await adapter.produce();
-    return normalizeRuntimeTrackingPayload(payload, endpoint, index);
+    if (runMode === "correlateexistingtraffic") {
+        return normalizeRuntimeObservedTrackingPayload(await adapter.consume(), endpoint);
+    }
+    return normalizeRuntimeTrackingPayload(await adapter.produce(), endpoint, index);
 }
-function mapRuntimeTrackingEndpointSpec(spec) {
+function mapRuntimeTrackingEndpointSpec(spec, useLoadStrikeTraceIdHeader = false) {
     const pollIntervalMs = Math.trunc(pickTrackingNumber(spec, ["PollIntervalMs", "pollIntervalMs"], pickTrackingNumber(spec, ["PollIntervalSeconds", "pollIntervalSeconds", "PollInterval"], 0.25) * 1000));
     const httpSpec = asTrackingRecord(pickTrackingValue(spec, "Http", "http"));
     const delegateSpec = asTrackingRecord(pickTrackingValue(spec, "delegate", "Delegate", "DelegateStream"));
@@ -6404,7 +6412,7 @@ function mapRuntimeTrackingEndpointSpec(spec) {
         kind: pickTrackingString(spec, "Kind", "kind", "DelegateStream"),
         mode: pickTrackingString(spec, "Mode", "mode", "Produce"),
         name: pickTrackingString(spec, "Name", "name", "endpoint"),
-        trackingField: pickTrackingSelectorString(spec, "TrackingField", "trackingField", "header:x-correlation-id"),
+        trackingField: pickTrackingSelectorString(spec, "TrackingField", "trackingField", useLoadStrikeTraceIdHeader ? LOADSTRIKE_TRACE_ID_TRACKING_FIELD : "header:x-correlation-id"),
         gatherByField: pickOptionalTrackingSelectorString(spec, "GatherByField", "gatherByField"),
         autoGenerateTrackingIdWhenMissing: pickTrackingBoolean(spec, "AutoGenerateTrackingIdWhenMissing", "autoGenerateTrackingIdWhenMissing", true),
         pollIntervalMs,
@@ -6510,7 +6518,9 @@ function normalizeRuntimeTrackingPayload(payload, endpoint, index) {
     if (existing || !endpoint.autoGenerateTrackingIdWhenMissing) {
         return normalized;
     }
-    const generated = `${endpoint.name}-auto-${index + 1}`;
+    const generated = endpoint.trackingField.trim().toLowerCase() === LOADSTRIKE_TRACE_ID_TRACKING_FIELD
+        ? randomUUID()
+        : `${endpoint.name}-auto-${index + 1}`;
     const selector = endpoint.trackingField.trim();
     if (selector.toLowerCase().startsWith("header:")) {
         const headerName = selector.slice("header:".length).trim();
@@ -8014,7 +8024,7 @@ function buildRichHtmlReport(result) {
     <section id="scenarios" class="panel active">
       ${bars || "<div>No scenario data.</div>"}
       <table>
-        <thead><tr><th>Scenario</th><th>Requests</th><th>OK</th><th>Fail</th><th>TotalBytes</th><th>AvgLatencyMs</th></tr></thead>
+        <thead><tr><th>Scenario</th><th>Requests</th><th>OK</th><th>Fail</th><th>TotalBytes</th><th>AvgLatency (ms)</th></tr></thead>
         <tbody>${scenarioRows || "<tr><td colspan='6'>No rows</td></tr>"}</tbody>
       </table>
     </section>

package/dist/esm/transports.js

@@ -1,5 +1,7 @@
 import { randomUUID } from "node:crypto";
 import { TrackingFieldSelector } from "./correlation.js";
+export const LOADSTRIKE_TRACE_ID_HEADER = "loadstrike-trace-id";
+export const LOADSTRIKE_TRACE_ID_TRACKING_FIELD = `header:${LOADSTRIKE_TRACE_ID_HEADER}`;
 class TrafficEndpointDefinitionModel {
     get JsonSerializerSettings() {
         return this.JsonSettings;
@@ -1048,8 +1050,9 @@ class HttpEndpointAdapter extends CallbackAdapter {
         if (this.endpoint.mode !== "Produce") {
             return null;
         }
-        const resolved = payload ?? this.defaultPayload();
         const httpOptions = this.endpoint.http;
+        const responseTracking = canonicalizeHttpTrackingPayloadSource(String(httpOptions?.trackingPayloadSource ?? "Request")) === "Response";
+        const resolved = prepareProducedPayload(this.endpoint, payload, !responseTracking);
         if (!httpOptions?.url) {
             return super.produce(resolved);
         }
@@ -2951,7 +2954,7 @@ function createDefaultPayload(endpoint) {
         jsonConvertSettings: endpoint.jsonConvertSettings ? { ...endpoint.jsonConvertSettings } : undefined
     });
 }
-function prepareProducedPayload(endpoint, payload) {
+function prepareProducedPayload(endpoint, payload, allowAutoGenerateTrackingId = true) {
     const base = payload
         ? attachPayloadHelpers({
             headers: {
@@ -2970,15 +2973,24 @@ function prepareProducedPayload(endpoint, payload) {
     if (trackingId) {
         return base;
     }
+    if (!allowAutoGenerateTrackingId) {
+        return base;
+    }
     if (endpoint.autoGenerateTrackingIdWhenMissing === false) {
         throw new Error(`Tracking id could not be extracted using selector \`${endpoint.trackingField}\` and AutoGenerateTrackingIdWhenMissing is disabled for endpoint \`${endpoint.name}\`.`);
     }
-    const generated = randomUUID().replace(/-/g, "");
+    const generated = isLoadStrikeTraceSelector(endpoint.trackingField)
+        ? randomUUID()
+        : randomUUID().replace(/-/g, "");
     if (!injectTrackingValue(base, endpoint.trackingField, generated)) {
         throw new Error(`Tracking id could not be injected using selector \`${endpoint.trackingField}\` for endpoint \`${endpoint.name}\`. Verify the selector and payload shape.`);
     }
     return base;
 }
+function isLoadStrikeTraceSelector(selector) {
+    const trimmed = selector.trim();
+    return trimmed.toLowerCase() === LOADSTRIKE_TRACE_ID_TRACKING_FIELD;
+}
 function toWirePayload(payload, endpoint) {
     return {
         headers: { ...(payload.headers ?? {}) },

package/dist/types/contracts.d.ts

@@ -76,6 +76,7 @@ export interface LoadStrikeTrackingConfigurationSpec {
     TrackingFieldValueCaseSensitive?: boolean;
     GatherByFieldValueCaseSensitive?: boolean;
     ExecuteOriginalScenarioRun?: boolean;
+    UseLoadStrikeTraceIdHeader?: boolean;
     MetricPrefix?: string;
     CorrelationStore?: LoadStrikeCorrelationStoreSpec;
 }
@@ -93,7 +94,7 @@ export interface LoadStrikeEndpointSpec {
     Kind: string;
     Name: string;
     Mode: string;
-    TrackingField: string;
+    TrackingField?: string;
     GatherByField?: string;
     AutoGenerateTrackingIdWhenMissing?: boolean;
     PollIntervalSeconds?: number;

package/dist/types/index.d.ts

@@ -6,7 +6,7 @@ export { CrossPlatformScenarioConfigurator, ScenarioTrackingExtensions, LoadStri
 export type { ILoadStrikeReportingSink, ILoadStrikeWorkerPlugin, LoadStrikeRunResult, LoadStrikeReportingSink, LoadStrikeRuntimePolicy, LoadStrikeRunnerOptions, LoadStrikeRunContext as LoadStrikeRuntimeContext, LoadStrikeRunContext, LoadStrikeBaseContext, LoadStrikeCounterStats, LoadStrikeDataTransferStats, LoadStrikeGaugeStats, LoadStrikeLogger, LoadStrikeLoadSimulationStats, LoadStrikeMeasurementStats, LoadStrikeMetricStats, LoadStrikeNodeInfo, LoadStrikeMetricValue, LoadStrikeRandom, LoadStrikeReply, LoadStrikeLatencyCount, LoadStrikeLatencyStats, LoadStrikeLoadSimulation, LoadStrikeScenarioInfo, LoadStrikeScenarioInitContext, LoadStrikeScenarioPartition, LoadStrikeScenarioStartInfo, LoadStrikeScenarioContext, LoadStrikeScenarioStats, LoadStrikeTestInfo, LoadStrikeScenarioRuntime, LoadStrikeSessionStartInfo, LoadStrikeSinkSession, LoadStrikeSinkError, LoadStrikeStatusCodeStats, LoadStrikeThresholdResult, LoadStrikeThresholdPredicateContext, CrossPlatformTrackingConfiguration, LoadStrikeStepReply, LoadStrikeStepStats, LoadStrikeStepRuntime, LoadStrikeThresholdOptions, LoadStrikeRequestStats, LoadStrikeWorkerPlugin } from "./runtime.js";
 export { CorrelationStoreConfiguration, CrossPlatformTrackingRuntime, InMemoryCorrelationStore, RedisCorrelationStoreOptions, RedisCorrelationStore, TrackingPayloadBuilder, TrackingFieldSelector } from "./correlation.js";
 export type { CorrelationEntry, DestinationConsumeResult, GatheredRow, CorrelationStoreKind, CorrelationRuntimeOptions, CorrelationRuntimePlugin, CorrelationRuntimeStats, CorrelationStore, SourceProduceResult, TrackingFieldLocation, TrackingPayload } from "./correlation.js";
-export { EndpointAdapterFactory, TrafficEndpointDefinition, HttpEndpointDefinition, KafkaEndpointDefinition, KafkaSaslOptions, RabbitMqEndpointDefinition, NatsEndpointDefinition, RedisStreamsEndpointDefinition, AzureEventHubsEndpointDefinition, DelegateStreamEndpointDefinition, PushDiffusionEndpointDefinition, HttpOAuth2ClientCredentialsOptions, HttpAuthOptions } from "./transports.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 type { EndpointAdapter, EndpointDefinition, EndpointDefinitionInput, EndpointKind, EndpointMode, DotNetDelegateEndpointOptions, DotNetEndpointDefinition, DotNetHttpAuthOptions, DotNetHttpEndpointOptions, DotNetHttpOAuth2ClientCredentialsOptions, HttpAuthMode, HttpAuthType, HttpRequestBodyType, HttpResponseSource, HttpTrackingPayloadSource, KafkaSaslMechanismType, KafkaSecurityProtocolType, HttpEndpointOptions, KafkaEndpointOptions, RabbitMqEndpointOptions, NatsEndpointOptions, RedisStreamsEndpointOptions, AzureEventHubsEndpointOptions, PushDiffusionEndpointOptions, TrackingFieldSelectorInput, TrackingRunMode, TrafficEndpointKind, TrafficEndpointMode, ProducedMessageRequest, ProducedMessageResult, ConsumedMessage, DelegateConsumeAsync, DelegateConsumeStreamHandler, DelegateEndpointOptions } from "./transports.js";
 export { DatadogReportingSink, DatadogReportingSinkOptions, GrafanaLokiReportingSink, GrafanaLokiReportingSinkOptions, InfluxDbReportingSink, InfluxDbReportingSinkOptions, OtelCollectorReportingSink, OtelCollectorReportingSinkOptions, SplunkReportingSink, SplunkReportingSinkOptions, TimescaleDbReportingSink, TimescaleDbReportingSinkOptions } from "./sinks.js";
 export type { DatadogSinkOptions, GrafanaLokiSinkOptions, InfluxDbSinkOptions, OtelCollectorSinkOptions, SplunkSinkOptions, TimescaleDbSinkOptions } from "./sinks.js";

package/dist/types/local.d.ts

@@ -67,7 +67,7 @@ declare function evaluateScenarioOutcome(scenario: Record<string, unknown>, requ
 }>;
 declare function validateTrackingConfiguration(tracking: Record<string, unknown>, sourceEndpoint: EndpointDefinition, destinationEndpoint: EndpointDefinition | null): void;
 declare function inferLegacyHttpResponseSourceValue(value: string | undefined): "ResponseBody" | "ResponseHeaders" | "ResponseStatusCode" | undefined;
-declare function mapEndpointSpec(spec: Record<string, unknown>): EndpointDefinition;
+declare function mapEndpointSpec(spec: Record<string, unknown>, useLoadStrikeTraceIdHeader?: boolean): EndpointDefinition;
 declare function normalizePayload(payload: TrackingPayload | null, endpoint: EndpointDefinition, index: number): TrackingPayload;
 declare function readTrackingId(payload: TrackingPayload, selector: string): string | null;
 declare function readOptionalTrackingSelectorValue(value: unknown): string | undefined;

package/dist/types/runtime.d.ts

@@ -2103,7 +2103,7 @@ declare function readRuntimeRedisCorrelationStoreOptions(redisSpec: Record<strin
 declare function buildTrackingRunNamespace(sessionId: string, scenarioName: string, sourceName: string, destinationName?: string | null): string;
 declare function sanitizeTrackingNamespacePart(value: string): string;
 declare function produceOrConsumeTrackingPayload(adapter: EndpointAdapter, endpoint: EndpointDefinition, runMode: string, index: number): Promise<TrackingPayload | null>;
-declare function mapRuntimeTrackingEndpointSpec(spec: Record<string, unknown>): EndpointDefinition;
+declare function mapRuntimeTrackingEndpointSpec(spec: Record<string, unknown>, useLoadStrikeTraceIdHeader?: boolean): EndpointDefinition;
 declare function normalizeRuntimeTrackingPayload(payload: TrackingPayload | null, endpoint: EndpointDefinition, index: number): TrackingPayload;
 declare function readRuntimeTrackingId(payload: TrackingPayload, selector: string): string | null;
 declare function runtimeParseBodyAsObject(body: unknown): Record<string, unknown> | null;

package/dist/types/transports.d.ts

@@ -1,4 +1,6 @@
 import { TrackingFieldSelector, type TrackingPayload } from "./correlation.js";
+export declare const LOADSTRIKE_TRACE_ID_HEADER = "loadstrike-trace-id";
+export declare const LOADSTRIKE_TRACE_ID_TRACKING_FIELD = "header:loadstrike-trace-id";
 export type EndpointKind = "Http" | "Kafka" | "RabbitMq" | "Nats" | "RedisStreams" | "AzureEventHubs" | "PushDiffusion" | "DelegateStream";
 export type EndpointMode = "Produce" | "Consume";
 export type HttpAuthMode = "None" | "Basic" | "Bearer" | "OAuth2ClientCredentials";
@@ -804,7 +806,7 @@ declare function attachPayloadHelpers(payload: TrackingPayload): TrackingPayload
 declare function attachDotNetTrackingPayloadAliases<T extends TrackingPayload>(payload: T): T;
 declare function attachStructuredProducedMessageRequestAliases(request: ProducedMessageRequest, endpoint: EndpointDefinition): ProducedMessageRequest;
 declare function createDelegateRequestEndpointView(endpoint: EndpointDefinition): Record<string, unknown>;
-declare function prepareProducedPayload(endpoint: EndpointDefinition, payload?: TrackingPayload): TrackingPayload;
+declare function prepareProducedPayload(endpoint: EndpointDefinition, payload?: TrackingPayload, allowAutoGenerateTrackingId?: boolean): TrackingPayload;
 declare function serializePayloadBody(body: unknown, contentType?: string): Uint8Array;
 declare function deserializeBrokerPayloadBody(body: Uint8Array, contentType?: string, messagePayloadType?: string): unknown;
 declare function extractTrackingValue(payload: TrackingPayload, selector: string): string | null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loadstrike/loadstrike-sdk",
-  "version": "1.0.21401",
+  "version": "1.0.22301",
   "description": "TypeScript and JavaScript SDK for in-process load execution, traffic correlation, and reporting.",
   "keywords": [
     "load-testing",