@loadstrike/loadstrike-sdk 1.0.31601 → 1.0.32601

package/dist/esm/sinks.js

@@ -4,28 +4,27 @@ import { appendFile, mkdir } from "node:fs/promises";
 import { dirname } from "node:path";
 import { createSocket } from "node:dgram";
 import { gzip } from "node:zlib";
+import { CloudWatchClient, PutMetricDataCommand } from "@aws-sdk/client-cloudwatch";
 import { Pool } from "pg";
+import { compress as compressSnappy } from "snappyjs";
 import { serializeIterationObservationBatchGzipJson } from "./iteration-observations.js";
 import { redactIterationObservationSecrets } from "./iteration-observation-diagnostics.js";
+import { encodePrometheusRemoteWrite } from "./internal/prometheus-remote-write.js";
+import { ReportingSinkHttpError } from "./internal/reporting-sink-http-error.js";
+import { createCloudWatchMetricData, encodeDynatraceMetricBatches, encodeNewRelicMetricBatches } from "./internal/vendor-metric-payloads.js";
 const PORTAL_RUN_TOKEN_PROVIDER = Symbol.for("loadstrike.internal.portal-run-token-provider");
+const REPORTING_INTERVAL_SECONDS = Symbol.for("loadstrike.internal.reporting-interval-seconds");
+const SEND_DIRECT_VENDOR_PROTOCOL_POINTS = Symbol("loadstrike.internal.send-direct-vendor-protocol-points");
+const CLONE_DIRECT_VENDOR_FOR_RUN = Symbol("loadstrike.internal.clone-direct-vendor-for-run");
+const CLOUDWATCH_MAXIMUM_DATUMS_PER_REQUEST = 1000;
+const CLOUDWATCH_SAFE_REQUEST_BODY_BYTES = 900 * 1024;
+const DIRECT_VENDOR_MAXIMUM_BODY_BYTES_EXCLUSIVE = 1000000;
+const MAXIMUM_NON_NEGATIVE_SIGNED_INT64 = 9223372036854775807n;
+const LOADSTRIKE_TYPESCRIPT_SDK_USER_AGENT = "loadstrike-typescript-sdk/1.0.16101";
+const EXPANDED_REPORTING_SINK_BINDINGS = new WeakMap();
 const MAXIMUM_HTTP_RESPONSE_BODY_BYTES = 256 * 1024;
 const MAXIMUM_HTTP_METADATA_CHARACTERS = 256;
 const HTTP_METADATA_TRUNCATION_SUFFIX = " [truncated]";
-class ReportingSinkHttpError extends Error {
-    constructor(sinkName, status, statusText, requestId) {
-        const normalizedStatus = Number.isFinite(status) ? Math.max(Math.trunc(status), 0) : 0;
-        const normalizedStatusText = normalizeHttpMetadata(statusText);
-        const normalizedRequestId = normalizeHttpMetadata(requestId);
-        super(`${sinkName} write failed with HTTP status ${normalizedStatus}`
-            + (normalizedStatusText ? ` ${normalizedStatusText}` : "")
-            + (normalizedRequestId ? ` (requestId=${normalizedRequestId})` : "")
-            + ".");
-        this.name = "ReportingSinkHttpError";
-        this.status = normalizedStatus;
-        this.statusText = normalizedStatusText;
-        this.requestId = normalizedRequestId;
-    }
-}
 function gzipJsonAsync(value) {
     const json = Buffer.from(JSON.stringify(value), "utf8");
     return new Promise((resolve, reject) => {
@@ -564,12 +563,72 @@ export class PortalReportingSink {
         return current || this.runToken;
     }
 }
-export function cloneReportingSinkForRun(sink) {
+export function cloneReportingSinkForRun(sink, infraConfig = {}, environment = process.env) {
     if (sink instanceof PortalReportingSink) {
         return sink.cloneForRun();
     }
+    if (sink instanceof CompositeReportingSink) {
+        const children = sink.sinks;
+        if (sink.constructor !== CompositeReportingSink &&
+            !hasSelectedExpandedConfiguration(children, infraConfig, environment)) {
+            return sink;
+        }
+        const boundChildren = children.map((child) => cloneReportingSinkForRun(child, infraConfig, environment));
+        if (boundChildren.every((child, index) => child === children[index])) {
+            return sink;
+        }
+        if (sink.constructor !== CompositeReportingSink) {
+            throw new Error(`${sink.constructor.name || "Custom composite reporting sink"} cannot bind child configuration `
+                + "without an explicit clone implementation. Configure its children in code instead.");
+        }
+        return new CompositeReportingSink(...boundChildren);
+    }
+    const expandedBinding = EXPANDED_REPORTING_SINK_BINDINGS.get(sink);
+    if (expandedBinding) {
+        const configuredSection = readExpandedConfigSection(infraConfig, environment, expandedBinding.configurationSectionPath);
+        const expectedConstructor = expandedReportingSinkConstructor(expandedBinding.kind);
+        if (!configuredSection.present && sink.constructor !== expectedConstructor) {
+            return sink;
+        }
+        if (configuredSection.present) {
+            assertExpandedSinkSupportsConfigurationBinding(sink, expandedBinding.kind, configuredSection.path);
+        }
+        assertExpandedSinkExecutableOptions(expandedBinding);
+        if (!configuredSection.present) {
+            if (!(sink instanceof DirectVendorMetricReportingSink)) {
+                return sink;
+            }
+            return sink.constructor === expectedConstructor
+                ? sink[CLONE_DIRECT_VENDOR_FOR_RUN]()
+                : sink;
+        }
+        return createBoundExpandedReportingSink(sink, expandedBinding, infraConfig, environment);
+    }
+    if (sink instanceof DirectVendorMetricReportingSink) {
+        return sink[CLONE_DIRECT_VENDOR_FOR_RUN]();
+    }
     return sink;
 }
+function hasSelectedExpandedConfiguration(sinks, infraConfig, environment, visited = new Set()) {
+    for (const sink of sinks) {
+        if (visited.has(sink)) {
+            continue;
+        }
+        visited.add(sink);
+        if (sink instanceof CompositeReportingSink) {
+            const children = sink.sinks;
+            if (hasSelectedExpandedConfiguration(children, infraConfig, environment, visited)) {
+                return true;
+            }
+            continue;
+        }
+        const binding = EXPANDED_REPORTING_SINK_BINDINGS.get(sink);
+        if (binding && readExpandedConfigSection(infraConfig, environment, binding.configurationSectionPath).present) {
+            return true;
+        }
+    }
+    return false;
+}
 export class InfluxDbReportingSink {
     constructor(options = {}) {
         this.sinkName = "influxdb";
@@ -1626,27 +1685,34 @@ class ExpandedEventReportingSink {
     }
 }
 class ExpandedHttpJsonReportingSink extends ExpandedEventReportingSink {
-    constructor(sinkName, licenseFeature, defaultEndpointPath, options = {}) {
+    constructor(sinkName, licenseFeature, defaultEndpointPath, options = {}, bindingOptions = options) {
         super(sinkName, licenseFeature);
         const source = asRecord(options);
         this.baseUrl = optionString(source, "baseUrl", "BaseUrl").trim();
+        this.exactUrl = optionString(source, "__loadstrikeExactUrl").trim();
         this.endpointPath = optionString(source, "endpointPath", "EndpointPath").trim() || defaultEndpointPath;
         this.headers = normalizeStringMap(optionRecord(source, "headers", "Headers"));
         this.staticTags = normalizeStringMap(optionRecord(source, "staticTags", "StaticTags"));
         this.timeoutMs = resolveTimeoutMs(optionNumber(source, "timeoutSeconds", "TimeoutSeconds"), optionNumber(source, "timeoutMs", "TimeoutMs"));
         this.fetchImpl = pickRecordValue(source, "fetchImpl", "FetchImpl") ?? fetch;
+        const expandedKind = expandedReportingSinkKindFromName(sinkName);
+        if (expandedKind) {
+            rememberExpandedReportingSink(this, expandedKind, asRecord(bindingOptions));
+        }
     }
     init(context, infraConfig) {
         super.init(context, infraConfig);
-        if (!this.baseUrl.trim()) {
+        const configuredUrl = this.exactUrl || this.baseUrl;
+        if (!configuredUrl) {
             throw new Error(`${this.constructor.name} requires BaseUrl.`);
         }
+        requireHttpReportingUrl(configuredUrl, `${this.constructor.name} BaseUrl`);
     }
     async persistEvents(events) {
         if (!events.length) {
             return;
         }
-        await postWithTimeout(this.fetchImpl, `${trimTrailingSlashes(this.baseUrl)}${normalizePath(this.endpointPath)}`, {
+        await postWithTimeout(this.fetchImpl, this.requestUrl(), {
             method: "POST",
             headers: {
                 "Content-Type": "application/json",
@@ -1663,7 +1729,7 @@ class ExpandedHttpJsonReportingSink extends ExpandedEventReportingSink {
     }
     async persistCanonicalGzipPayload(payload) {
         const compressed = await gzipJsonAsync(payload);
-        await postWithTimeout(this.fetchImpl, `${trimTrailingSlashes(this.baseUrl)}${normalizePath(this.endpointPath)}`, {
+        await postWithTimeout(this.fetchImpl, this.requestUrl(), {
             method: "POST",
             headers: {
                 "Content-Type": "application/json",
@@ -1673,40 +1739,408 @@ class ExpandedHttpJsonReportingSink extends ExpandedEventReportingSink {
             body: Uint8Array.from(compressed).buffer
         }, this.timeoutMs, this.constructor.name);
     }
+    requestUrl() {
+        return this.exactUrl
+            || `${trimTrailingSlashes(this.baseUrl)}${normalizePath(this.endpointPath)}`;
+    }
+}
+function cloneDirectVendorSinkOptions(options) {
+    const source = (options ?? {});
+    return {
+        ...source,
+        ...(source.Headers ? { Headers: { ...source.Headers } } : {}),
+        ...(source.headers ? { headers: { ...source.headers } } : {}),
+        ...(source.StaticTags ? { StaticTags: { ...source.StaticTags } } : {}),
+        ...(source.staticTags ? { staticTags: { ...source.staticTags } } : {})
+    };
+}
+class DirectVendorMetricReportingSink extends ExpandedEventReportingSink {
+    constructor(sinkName, licenseFeature, defaultEndpointPath, options, requireBaseUrl = true) {
+        super(sinkName, licenseFeature);
+        this.iterationObservationShapeLimited = true;
+        this.previousCounts = new Map();
+        this.previousCountTimes = new Map();
+        this.stateGeneration = 0;
+        this.stateQueue = Promise.resolve();
+        const source = asRecord(options);
+        this.baseUrl = optionString(source, "endpointUrl", "EndpointUrl", "baseUrl", "BaseUrl").trim();
+        this.endpointPath = optionString(source, "endpointPath", "EndpointPath").trim() || defaultEndpointPath;
+        this.headers = normalizeProtocolHeaders(normalizeStringMap(optionRecord(source, "headers", "Headers")));
+        this.staticTags = normalizeStringMap(optionRecord(source, "staticTags", "StaticTags"));
+        this.timeoutMs = resolveTimeoutMs(optionNumber(source, "timeoutSeconds", "TimeoutSeconds"), optionNumber(source, "timeoutMs", "TimeoutMs"));
+        this.fetchImpl = pickRecordValue(source, "fetchImpl", "FetchImpl") ?? fetch;
+        const expandedKind = expandedReportingSinkKindFromName(sinkName);
+        if (expandedKind) {
+            rememberExpandedReportingSink(this, expandedKind, source);
+        }
+        this.configuredRunId = optionString(source, "runId", "RunId").trim();
+        this.requireBaseUrl = requireBaseUrl;
+        this.configuredFirstIntervalMs = reportingIntervalMilliseconds(optionNumber(source, "reportingIntervalSeconds", "ReportingIntervalSeconds"));
+    }
+    init(context, infraConfig) {
+        super.init(context, infraConfig);
+        const runtimeInterval = context[REPORTING_INTERVAL_SECONDS];
+        if (runtimeInterval !== undefined) {
+            this.configuredFirstIntervalMs = reportingIntervalMilliseconds(Number(runtimeInterval));
+        }
+        if (this.requireBaseUrl && !this.baseUrl) {
+            throw new Error(`${this.constructor.name} requires BaseUrl.`);
+        }
+        if (this.baseUrl) {
+            requireHttpReportingUrl(this.baseUrl, `${this.constructor.name} BaseUrl`);
+        }
+    }
+    start(session) {
+        super.start(session);
+        this.stateGeneration += 1;
+        this.previousCounts.clear();
+        this.previousCountTimes.clear();
+        const parsedStartedUtc = new Date(this.getSession().startedUtc);
+        this.runStartedUtc = Number.isFinite(parsedStartedUtc.getTime()) ? parsedStartedUtc : undefined;
+    }
+    stop() {
+        this.stateGeneration += 1;
+        this.previousCounts.clear();
+        this.previousCountTimes.clear();
+        this.runStartedUtc = undefined;
+        super.stop();
+    }
+    async persistEvents(events) {
+        if (!events.length) {
+            return;
+        }
+        const generation = this.stateGeneration;
+        const eventRunId = String(events[0]?.sessionId ?? "").trim();
+        const operation = this.stateQueue.then(async () => {
+            const occurredUtc = new Date();
+            const points = createDirectVendorMetricPoints(events, occurredUtc, this.configuredRunId || eventRunId, this.sinkName);
+            if (!points.length) {
+                return;
+            }
+            const prepared = this.prepareStatefulPoints(points);
+            await this[SEND_DIRECT_VENDOR_PROTOCOL_POINTS](prepared.points);
+            if (generation === this.stateGeneration) {
+                this.previousCounts = prepared.counts;
+                this.previousCountTimes = prepared.countTimes;
+            }
+        });
+        this.stateQueue = operation.then(() => undefined, () => undefined);
+        await operation;
+    }
+    prepareStatefulPoints(points) {
+        const counts = new Map(this.previousCounts);
+        const countTimes = new Map(Array.from(this.previousCountTimes, ([key, value]) => [key, new Date(value.getTime())]));
+        const prepared = [];
+        for (const point of points) {
+            if (point.metricKind !== "count") {
+                prepared.push(point);
+                continue;
+            }
+            const key = directVendorMetricSeriesKey(point);
+            const previousValue = counts.get(key);
+            const previousTime = countTimes.get(key);
+            const intervalMs = previousValue === undefined && this.configuredFirstIntervalMs !== undefined
+                ? this.configuredFirstIntervalMs
+                : positiveIntervalMilliseconds(previousTime ?? this.runStartedUtc, point.occurredUtc);
+            const value = this.sinkName === "prometheus-remote-write" || previousValue === undefined
+                ? point.value
+                : point.value >= previousValue
+                    ? point.value - previousValue
+                    : point.value;
+            prepared.push({ ...point, value, intervalMs });
+            counts.set(key, point.value);
+            countTimes.set(key, new Date(point.occurredUtc.getTime()));
+        }
+        return { points: prepared, counts, countTimes };
+    }
 }
-export class PrometheusRemoteWriteReportingSink extends ExpandedHttpJsonReportingSink {
+export class PrometheusRemoteWriteReportingSink extends DirectVendorMetricReportingSink {
     constructor(options = {}) {
         super("prometheus-remote-write", "extensions.reporting_sinks.prometheus_remote_write", "/api/v1/write", options);
-        this.iterationObservationShapeLimited = true;
+        this.bearerToken = optionString(asRecord(options), "bearerToken", "BearerToken").trim();
+        this.cloneOptions = cloneDirectVendorSinkOptions(options);
+        rememberExpandedReportingSink(this, "PrometheusRemoteWrite", asRecord(options));
+    }
+    [CLONE_DIRECT_VENDOR_FOR_RUN]() {
+        return new PrometheusRemoteWriteReportingSink(cloneDirectVendorSinkOptions(this.cloneOptions));
+    }
+    async [SEND_DIRECT_VENDOR_PROTOCOL_POINTS](points) {
+        const encoded = encodePrometheusRemoteWrite(points, this.staticTags);
+        const body = Uint8Array.from(compressSnappy(encoded.body));
+        await postWithTimeout(this.fetchImpl, `${trimTrailingSlashes(this.baseUrl)}${normalizePath(this.endpointPath)}`, {
+            method: "POST",
+            headers: mergeProtocolHeaders(this.headers, {
+                ...(this.bearerToken ? { Authorization: `Bearer ${this.bearerToken}` } : {}),
+                "Content-Type": encoded.contentType,
+                "Content-Encoding": "snappy",
+                "X-Prometheus-Remote-Write-Version": "0.1.0",
+                "User-Agent": LOADSTRIKE_TYPESCRIPT_SDK_USER_AGENT
+            }),
+            body: body.buffer
+        }, this.timeoutMs, this.constructor.name, true);
+    }
+}
+export class CloudWatchReportingSink extends DirectVendorMetricReportingSink {
+    constructor(options = {}) {
+        super("cloudwatch", "extensions.reporting_sinks.cloudwatch", "/", options, false);
+        const source = asRecord(options);
+        this.namespace = optionString(source, "namespace", "Namespace").trim() || "LoadStrike";
+        this.region = optionString(source, "region", "Region").trim();
+        this.accessKeyId = optionString(source, "accessKeyId", "AccessKeyId").trim();
+        this.secretAccessKey = optionString(source, "secretAccessKey", "SecretAccessKey").trim();
+        this.sessionToken = optionString(source, "sessionToken", "SessionToken").trim();
+        this.cloneOptions = cloneDirectVendorSinkOptions(options);
+        rememberExpandedReportingSink(this, "CloudWatch", source);
+    }
+    [CLONE_DIRECT_VENDOR_FOR_RUN]() {
+        return new CloudWatchReportingSink(cloneDirectVendorSinkOptions(this.cloneOptions));
+    }
+    init(context, infraConfig) {
+        if (normalizePath(this.endpointPath) !== "/") {
+            throw new Error("CloudWatchReportingSink does not support EndpointPath; include any required path in EndpointUrl.");
+        }
+        if (!this.namespace) {
+            throw new Error("CloudWatchReportingSink requires Namespace.");
+        }
+        if (!this.region) {
+            throw new Error("CloudWatchReportingSink requires Region.");
+        }
+        if (!this.accessKeyId) {
+            throw new Error("CloudWatchReportingSink requires AccessKeyId.");
+        }
+        if (!this.secretAccessKey) {
+            throw new Error("CloudWatchReportingSink requires SecretAccessKey.");
+        }
+        super.init(context, infraConfig);
+        this.cloudWatchClient?.destroy();
+        this.cloudWatchClient = new CloudWatchClient({
+            region: this.region,
+            credentials: {
+                accessKeyId: this.accessKeyId,
+                secretAccessKey: this.secretAccessKey,
+                ...(this.sessionToken ? { sessionToken: this.sessionToken } : {})
+            },
+            ...(this.baseUrl ? { endpoint: this.baseUrl } : {}),
+            maxAttempts: 1
+        });
+        const customHeaders = Object.fromEntries(Object.entries(this.headers).filter(([name]) => !isCloudWatchProtocolHeader(name)));
+        if (Object.keys(customHeaders).length > 0) {
+            this.cloudWatchClient.middlewareStack.add((next) => async (args) => {
+                const request = args.request;
+                if (request?.headers) {
+                    const merged = mergeProtocolHeaders(request.headers, customHeaders);
+                    for (const name of Object.keys(request.headers)) {
+                        delete request.headers[name];
+                    }
+                    Object.assign(request.headers, merged);
+                }
+                return next(args);
+            }, { step: "build", name: "loadStrikeCloudWatchHeaders", priority: "low" });
+        }
+    }
+    Dispose() {
+        this.cloudWatchClient?.destroy();
+        this.cloudWatchClient = undefined;
+        super.Dispose();
+    }
+    async [SEND_DIRECT_VENDOR_PROTOCOL_POINTS](points) {
+        const client = this.cloudWatchClient;
+        if (!client) {
+            throw new Error("CloudWatchReportingSink has not been initialized.");
+        }
+        const payload = createCloudWatchMetricData(this.namespace, points, this.staticTags);
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), Math.max(this.timeoutMs, 1));
+        try {
+            for (const batch of createCloudWatchMetricDataBatches(payload.Namespace, payload.MetricData)) {
+                await client.send(new PutMetricDataCommand(batch), { abortSignal: controller.signal });
+            }
+        }
+        catch (error) {
+            if (controller.signal.aborted) {
+                throw new DOMException("CloudWatchReportingSink request aborted.", "AbortError");
+            }
+            void error;
+            throw new Error("CloudWatchReportingSink write failed.");
+        }
+        finally {
+            clearTimeout(timer);
+        }
     }
 }
-export class CloudWatchReportingSink extends ExpandedHttpJsonReportingSink {
+export class DynatraceReportingSink extends DirectVendorMetricReportingSink {
     constructor(options = {}) {
-        super("cloudwatch", "extensions.reporting_sinks.cloudwatch", "/loadstrike/events", options);
-        this.iterationObservationShapeLimited = true;
+        super("dynatrace", "extensions.reporting_sinks.dynatrace", "/api/v2/metrics/ingest", options);
+        this.apiToken = optionString(asRecord(options), "apiToken", "ApiToken").trim();
+        this.cloneOptions = cloneDirectVendorSinkOptions(options);
+        rememberExpandedReportingSink(this, "Dynatrace", asRecord(options));
+    }
+    [CLONE_DIRECT_VENDOR_FOR_RUN]() {
+        return new DynatraceReportingSink(cloneDirectVendorSinkOptions(this.cloneOptions));
+    }
+    init(context, infraConfig) {
+        if (!this.apiToken && !hasCaseInsensitiveHeader(this.headers, "Authorization")) {
+            throw new Error("DynatraceReportingSink requires ApiToken.");
+        }
+        super.init(context, infraConfig);
+    }
+    async [SEND_DIRECT_VENDOR_PROTOCOL_POINTS](points) {
+        const batches = encodeDynatraceMetricBatches(points, this.staticTags, DIRECT_VENDOR_MAXIMUM_BODY_BYTES_EXCLUSIVE);
+        for (const encoded of batches) {
+            await postWithTimeout(this.fetchImpl, `${trimTrailingSlashes(this.baseUrl)}${normalizePath(this.endpointPath)}`, {
+                method: "POST",
+                headers: mergeProtocolHeaders(this.headers, {
+                    ...(this.apiToken ? { Authorization: `Api-Token ${this.apiToken}` } : {}),
+                    "Content-Type": encoded.contentType
+                }),
+                body: Uint8Array.from(encoded.body).buffer
+            }, this.timeoutMs, this.constructor.name);
+        }
     }
 }
-export class DynatraceReportingSink extends ExpandedHttpJsonReportingSink {
+export class NewRelicReportingSink extends DirectVendorMetricReportingSink {
     constructor(options = {}) {
-        super("dynatrace", "extensions.reporting_sinks.dynatrace", "/api/v2/logs/ingest", options);
-        this.iterationObservationShapeLimited = true;
+        super("new-relic", "extensions.reporting_sinks.new_relic", "/metric/v1", options);
+        this.licenseKey = optionString(asRecord(options), "licenseKey", "LicenseKey", "apiKey", "ApiKey").trim();
+        this.cloneOptions = cloneDirectVendorSinkOptions(options);
+        rememberExpandedReportingSink(this, "NewRelic", asRecord(options));
+    }
+    [CLONE_DIRECT_VENDOR_FOR_RUN]() {
+        return new NewRelicReportingSink(cloneDirectVendorSinkOptions(this.cloneOptions));
+    }
+    init(context, infraConfig) {
+        if (!this.licenseKey && !hasCaseInsensitiveHeader(this.headers, "Api-Key")) {
+            throw new Error("NewRelicReportingSink requires LicenseKey or ApiKey.");
+        }
+        super.init(context, infraConfig);
+    }
+    async [SEND_DIRECT_VENDOR_PROTOCOL_POINTS](points) {
+        const batches = encodeNewRelicMetricBatches(points, this.staticTags, DIRECT_VENDOR_MAXIMUM_BODY_BYTES_EXCLUSIVE);
+        for (const encoded of batches) {
+            await postWithTimeout(this.fetchImpl, `${trimTrailingSlashes(this.baseUrl)}${normalizePath(this.endpointPath)}`, {
+                method: "POST",
+                headers: mergeProtocolHeaders(this.headers, {
+                    ...(this.licenseKey ? { "Api-Key": this.licenseKey } : {}),
+                    "Content-Type": encoded.contentType
+                }),
+                body: Uint8Array.from(encoded.body).buffer
+            }, this.timeoutMs, this.constructor.name);
+        }
     }
 }
 export class ElasticsearchReportingSink extends ExpandedHttpJsonReportingSink {
     constructor(options = {}) {
-        super("elasticsearch", "extensions.reporting_sinks.elasticsearch", "/loadstrike-events/_doc", options);
+        const prepared = prepareSearchSinkOptions("Elasticsearch", options);
+        const defaultEndpointPath = prepared.usesIndexName
+            ? searchDocumentEndpointPath(prepared.indexName, "ElasticsearchReportingSink IndexName")
+            : "/loadstrike-events/_doc";
+        super("elasticsearch", "extensions.reporting_sinks.elasticsearch", defaultEndpointPath, prepared.options, options);
+        this.indexName = prepared.indexName;
+        this.usesIndexName = prepared.usesIndexName;
+    }
+    init(context, infraConfig) {
+        if (this.usesIndexName) {
+            requireValidSearchIndexName(this.indexName, `${this.constructor.name} IndexName`);
+        }
+        super.init(context, infraConfig);
     }
 }
 export class OpenSearchReportingSink extends ExpandedHttpJsonReportingSink {
     constructor(options = {}) {
-        super("opensearch", "extensions.reporting_sinks.opensearch", "/loadstrike-events/_doc", options);
+        const prepared = prepareSearchSinkOptions("OpenSearch", options);
+        const defaultEndpointPath = prepared.usesIndexName
+            ? searchDocumentEndpointPath(prepared.indexName, "OpenSearchReportingSink IndexName")
+            : "/loadstrike-events/_doc";
+        super("opensearch", "extensions.reporting_sinks.opensearch", defaultEndpointPath, prepared.options, options);
+        this.indexName = prepared.indexName;
+        this.usesIndexName = prepared.usesIndexName;
+        this.username = prepared.username;
+        this.password = prepared.password;
+    }
+    init(context, infraConfig) {
+        if (this.usesIndexName) {
+            requireValidSearchIndexName(this.indexName, `${this.constructor.name} IndexName`);
+        }
+        if (this.username && !this.password) {
+            throw new Error(`${this.constructor.name} requires Password when Username is configured.`);
+        }
+        if (this.password && !this.username) {
+            throw new Error(`${this.constructor.name} requires Username when Password is configured.`);
+        }
+        super.init(context, infraConfig);
     }
 }
-export class NewRelicReportingSink extends ExpandedHttpJsonReportingSink {
-    constructor(options = {}) {
-        super("new-relic", "extensions.reporting_sinks.new_relic", "/log/v1", options);
-        this.iterationObservationShapeLimited = true;
+function prepareSearchSinkOptions(kind, options) {
+    const source = asRecord(options);
+    const rawIndexName = pickRecordValue(source, "indexName", "IndexName");
+    const endpointPath = optionString(source, "endpointPath", "EndpointPath").trim();
+    const indexName = rawIndexName === undefined
+        ? "loadstrike-events"
+        : typeof rawIndexName === "string"
+            ? rawIndexName.trim()
+            : "";
+    let headers = normalizeStringMap(optionRecord(source, "headers", "Headers"));
+    let username = "";
+    let password = "";
+    if (kind === "Elasticsearch") {
+        const apiKey = optionString(source, "apiKey", "ApiKey").trim();
+        if (apiKey && !hasCaseInsensitiveHeader(headers, "Authorization")) {
+            headers = mergeProtocolHeaders(headers, { Authorization: `ApiKey ${apiKey}` });
+        }
+    }
+    else {
+        username = optionString(source, "username", "Username").trim();
+        password = optionString(source, "password", "Password");
+        if ((username || password) && !hasCaseInsensitiveHeader(headers, "Authorization")) {
+            headers = mergeProtocolHeaders(headers, {
+                Authorization: `Basic ${Buffer.from(`${username}:${password}`, "utf8").toString("base64")}`
+            });
+        }
     }
+    return {
+        indexName,
+        usesIndexName: !endpointPath,
+        username,
+        password,
+        options: { ...source, headers }
+    };
+}
+function searchDocumentEndpointPath(indexName, path) {
+    if (hasUnpairedUnicodeSurrogate(indexName)) {
+        throw new Error(`${path} must be a valid search index name.`);
+    }
+    return `/${encodeURIComponent(indexName)}/_doc`;
+}
+function requireValidSearchIndexName(indexName, path) {
+    const byteLength = Buffer.byteLength(indexName, "utf8");
+    const invalid = !indexName
+        || indexName !== indexName.toLowerCase()
+        || byteLength > 255
+        || indexName === "."
+        || indexName === ".."
+        || /^[\-_+]/u.test(indexName)
+        || /[?*\u002f\u005c\x22<>| ,#:]/u.test(indexName)
+        || /[\u0000-\u001f\u007f]/u.test(indexName)
+        || hasUnpairedUnicodeSurrogate(indexName);
+    if (invalid) {
+        throw new Error(`${path} must be a valid search index name.`);
+    }
+}
+function hasUnpairedUnicodeSurrogate(value) {
+    for (let index = 0; index < value.length; index += 1) {
+        const codeUnit = value.charCodeAt(index);
+        if (codeUnit >= 0xd800 && codeUnit <= 0xdbff) {
+            const next = index + 1 < value.length ? value.charCodeAt(index + 1) : -1;
+            if (next < 0xdc00 || next > 0xdfff) {
+                return true;
+            }
+            index += 1;
+        }
+        else if (codeUnit >= 0xdc00 && codeUnit <= 0xdfff) {
+            return true;
+        }
+    }
+    return false;
 }
 export class GenericWebhookReportingSink extends ExpandedHttpJsonReportingSink {
     constructor(options = {}) {
@@ -1731,8 +2165,17 @@ export class KafkaReportingSink extends ExpandedEventReportingSink {
         super("kafka", "extensions.reporting_sinks.kafka");
         const source = asRecord(options);
         this.topic = optionString(source, "topic", "Topic").trim() || "loadstrike-events";
+        this.bootstrapServers = optionString(source, "bootstrapServers", "BootstrapServers").trim();
         this.staticTags = normalizeStringMap(optionRecord(source, "staticTags", "StaticTags"));
         this.publishAsync = pickRecordValue(source, "publishAsync", "PublishAsync");
+        rememberExpandedReportingSink(this, "Kafka", source);
+    }
+    init(context, infraConfig) {
+        if (!this.publishAsync) {
+            throw new Error("KafkaReportingSink requires PublishAsync because TypeScript Kafka reporting is callback-backed; "
+                + "BootstrapServers does not enable native broker delivery.");
+        }
+        super.init(context, infraConfig);
     }
     async saveIterationBatch(batch) {
         await this.publishCanonicalValue(batch);
@@ -1767,6 +2210,10 @@ class StatsDReportingSinkBase extends ExpandedEventReportingSink {
         this.tags = normalizeStringMap(optionRecord(source, "tags", "Tags"));
         this.sendLineAsync = pickRecordValue(source, "sendLineAsync", "SendLineAsync");
         this.dogStatsD = dogStatsD;
+        const expandedKind = expandedReportingSinkKindFromName(sinkName);
+        if (expandedKind) {
+            rememberExpandedReportingSink(this, expandedKind, source);
+        }
     }
     async saveIterationBatch(batch) {
         for (const observation of batch.observations) {
@@ -1853,6 +2300,7 @@ export class JsonlFileReportingSink extends ExpandedEventReportingSink {
         const source = asRecord(options);
         this.filePath = optionString(source, "filePath", "FilePath").trim() || "loadstrike-reporting.jsonl";
         this.staticTags = normalizeStringMap(optionRecord(source, "staticTags", "StaticTags"));
+        rememberExpandedReportingSink(this, "Jsonl", source);
     }
     async persistEvents(events) {
         if (!events.length) {
@@ -2046,6 +2494,8 @@ function createScenarioEvent(session, occurredUtc, phase, scenario) {
         all_request_count: scenario.allRequestCount,
         all_ok_count: scenario.allOkCount,
         all_fail_count: scenario.allFailCount,
+        all_ok_count_64: scenario.ok?.count64 ?? scenario.ok?.Count64,
+        all_fail_count_64: scenario.fail?.count64 ?? scenario.fail?.Count64,
         all_bytes: scenario.allBytes,
         duration_ms: scenario.durationMs,
         sort_index: scenario.sortIndex,
@@ -2575,6 +3025,120 @@ function toReportingSinkEventJson(event) {
         Fields: event.fields
     });
 }
+function createDirectVendorMetricPoints(events, occurredUtc, runId, sinkName) {
+    const points = [];
+    for (const event of events) {
+        const eventType = String(event.eventType ?? "").trim().toLowerCase();
+        const scenario = String(event.scenarioName ?? "").trim() || "default";
+        const status = String(event.tags?.status ?? "").trim() || "ok";
+        if (eventType === "scenario.realtime" || eventType === "scenario.final") {
+            let statusCountPresent = false;
+            for (const scenarioStatus of ["ok", "fail"]) {
+                const count = protocolCountValue(sinkName, event.fields[`all_${scenarioStatus}_count_64`], event.fields[`all_${scenarioStatus}_count`], event.fields[`${scenarioStatus}_request_count`]);
+                statusCountPresent || (statusCountPresent = count.present);
+                if (!count.present || count.value === 0) {
+                    continue;
+                }
+                points.push({
+                    metricName: "loadstrike_requests_total",
+                    metricKind: "count",
+                    occurredUtc: new Date(occurredUtc.getTime()),
+                    value: count.value,
+                    unitOfMeasure: "count",
+                    scenario,
+                    status: scenarioStatus,
+                    ...(runId ? { runId } : {}),
+                    intervalMs: 1
+                });
+                const latency = event.fields[`${scenarioStatus}_latency_mean_ms`];
+                if (isFiniteNumberLike(latency)) {
+                    points.push({
+                        metricName: "loadstrike_request_duration_ms",
+                        metricKind: "gauge",
+                        occurredUtc: new Date(occurredUtc.getTime()),
+                        value: toNumericValue(latency),
+                        unitOfMeasure: "ms",
+                        scenario,
+                        status: scenarioStatus,
+                        ...(runId ? { runId } : {})
+                    });
+                }
+            }
+            if (!statusCountPresent && isFiniteNumberLike(event.fields.all_request_count)) {
+                points.push({
+                    metricName: "loadstrike_requests_total",
+                    metricKind: "count",
+                    occurredUtc: new Date(occurredUtc.getTime()),
+                    value: toNumericValue(event.fields.all_request_count),
+                    unitOfMeasure: "count",
+                    scenario,
+                    status,
+                    ...(runId ? { runId } : {}),
+                    intervalMs: 1
+                });
+            }
+            continue;
+        }
+        const isCounter = eventType.startsWith("metric.counter");
+        const isGauge = eventType.startsWith("metric.gauge");
+        if ((!isCounter && !isGauge) || !isFiniteNumberLike(event.fields.value)) {
+            continue;
+        }
+        const unit = event.fields.unit_of_measure;
+        points.push({
+            metricName: buildCustomMetricName(String(event.tags?.metric_name ?? "")),
+            metricKind: isCounter ? "count" : "gauge",
+            occurredUtc: new Date(occurredUtc.getTime()),
+            value: toNumericValue(event.fields.value),
+            ...(typeof unit === "string" ? { unitOfMeasure: unit } : {}),
+            scenario,
+            status,
+            ...(runId ? { runId } : {}),
+            ...(isCounter ? { intervalMs: 1 } : {})
+        });
+    }
+    return points;
+}
+function directVendorMetricSeriesKey(point) {
+    return JSON.stringify([
+        point.metricName,
+        point.scenario,
+        point.status,
+        point.runId ?? ""
+    ]);
+}
+function createCloudWatchMetricDataBatches(namespace, metricData) {
+    const emptyBodyBytes = Buffer.byteLength(JSON.stringify({ Namespace: namespace, MetricData: [] }), "utf8");
+    const batches = [];
+    let current = [];
+    let currentBodyBytes = emptyBodyBytes;
+    for (const datum of metricData) {
+        const datumBodyBytes = Buffer.byteLength(JSON.stringify(datum), "utf8");
+        const separatorBytes = current.length > 0 ? 1 : 0;
+        const exceedsDatumLimit = current.length >= CLOUDWATCH_MAXIMUM_DATUMS_PER_REQUEST;
+        const exceedsBodyLimit = currentBodyBytes + separatorBytes + datumBodyBytes > CLOUDWATCH_SAFE_REQUEST_BODY_BYTES;
+        if (current.length > 0 && (exceedsDatumLimit || exceedsBodyLimit)) {
+            batches.push({
+                Namespace: namespace,
+                MetricData: current
+            });
+            current = [];
+            currentBodyBytes = emptyBodyBytes;
+        }
+        if (currentBodyBytes + (current.length > 0 ? 1 : 0) + datumBodyBytes > CLOUDWATCH_SAFE_REQUEST_BODY_BYTES) {
+            throw new Error("CloudWatchReportingSink metric datum exceeds the safe request size.");
+        }
+        currentBodyBytes += (current.length > 0 ? 1 : 0) + datumBodyBytes;
+        current.push(datum);
+    }
+    if (current.length > 0) {
+        batches.push({
+            Namespace: namespace,
+            MetricData: current
+        });
+    }
+    return batches;
+}
 function createReportingSinkMetricPoints(sinkName, events, staticTags) {
     const points = [];
     for (const event of events) {
@@ -2686,6 +3250,45 @@ function toNumericValue(value) {
     }
     return Number(value);
 }
+function protocolCountValue(sinkName, ...values) {
+    let zeroPresent = false;
+    for (const value of values) {
+        if (value === undefined || value === null) {
+            continue;
+        }
+        let parsed;
+        if (typeof value === "string") {
+            const text = value.trim();
+            if (!text) {
+                continue;
+            }
+            if (!/^\d+$/.test(text)) {
+                throw invalidProtocolRequestCount(sinkName);
+            }
+            parsed = BigInt(text);
+        }
+        else if (typeof value === "bigint") {
+            parsed = value;
+        }
+        else if (typeof value === "number" && Number.isSafeInteger(value)) {
+            parsed = BigInt(value);
+        }
+        else {
+            throw invalidProtocolRequestCount(sinkName);
+        }
+        if (parsed < 0n || parsed > MAXIMUM_NON_NEGATIVE_SIGNED_INT64) {
+            throw invalidProtocolRequestCount(sinkName);
+        }
+        if (parsed !== 0n) {
+            return { value: Number(parsed), present: true };
+        }
+        zeroPresent = true;
+    }
+    return { value: 0, present: zeroPresent };
+}
+function invalidProtocolRequestCount(sinkName) {
+    return new Error(`${sinkName} request count must be a non-negative signed 64-bit integer.`);
+}
 function inferUnitOfMeasure(fieldName) {
     const normalized = fieldName.toLowerCase();
     if (normalized.endsWith("_ms")) {
@@ -3199,6 +3802,620 @@ function mergeOtelCollectorOptions(target, source) {
         target.staticResourceAttributes = normalizeStringMap(source.staticResourceAttributes);
     }
 }
+const DEFAULT_EXPANDED_REPORTING_SECTION_PATHS = {
+    PrometheusRemoteWrite: "LoadStrike:ReportingSinks:PrometheusRemoteWrite",
+    CloudWatch: "LoadStrike:ReportingSinks:CloudWatch",
+    Dynatrace: "LoadStrike:ReportingSinks:Dynatrace",
+    Elasticsearch: "LoadStrike:ReportingSinks:Elasticsearch",
+    OpenSearch: "LoadStrike:ReportingSinks:OpenSearch",
+    NewRelic: "LoadStrike:ReportingSinks:NewRelic",
+    Webhook: "LoadStrike:ReportingSinks:Webhook",
+    Kafka: "LoadStrike:ReportingSinks:Kafka",
+    StatsD: "LoadStrike:ReportingSinks:StatsD",
+    Netdata: "LoadStrike:ReportingSinks:Netdata",
+    DogStatsD: "LoadStrike:ReportingSinks:DogStatsD",
+    Jsonl: "LoadStrike:ReportingSinks:Jsonl"
+};
+const EXPANDED_HTTP_CONFIG_FIELDS = [
+    { canonicalName: "BaseUrl", valueKind: "string" },
+    { canonicalName: "EndpointPath", valueKind: "string" },
+    { canonicalName: "Headers", valueKind: "stringMap" },
+    { canonicalName: "StaticTags", valueKind: "stringMap" },
+    { canonicalName: "TimeoutSeconds", valueKind: "number" },
+    { canonicalName: "TimeoutMs", valueKind: "number" }
+];
+const DIRECT_VENDOR_CONFIG_FIELDS = [
+    ...EXPANDED_HTTP_CONFIG_FIELDS,
+    { canonicalName: "RunId", valueKind: "string" },
+    { canonicalName: "ReportingIntervalSeconds", valueKind: "number" }
+];
+const EXPANDED_CONFIG_FIELDS = {
+    PrometheusRemoteWrite: [
+        ...DIRECT_VENDOR_CONFIG_FIELDS,
+        { canonicalName: "BearerToken", valueKind: "string" }
+    ],
+    CloudWatch: [
+        ...DIRECT_VENDOR_CONFIG_FIELDS,
+        { canonicalName: "EndpointUrl", valueKind: "string" },
+        { canonicalName: "Namespace", valueKind: "string" },
+        { canonicalName: "Region", valueKind: "string" },
+        { canonicalName: "AccessKeyId", valueKind: "string" },
+        { canonicalName: "SecretAccessKey", valueKind: "string" },
+        { canonicalName: "SessionToken", valueKind: "string" }
+    ],
+    Dynatrace: [
+        ...DIRECT_VENDOR_CONFIG_FIELDS,
+        { canonicalName: "ApiToken", valueKind: "string" }
+    ],
+    Elasticsearch: [
+        ...EXPANDED_HTTP_CONFIG_FIELDS,
+        { canonicalName: "IndexName", valueKind: "string" },
+        { canonicalName: "ApiKey", valueKind: "string" }
+    ],
+    OpenSearch: [
+        ...EXPANDED_HTTP_CONFIG_FIELDS,
+        { canonicalName: "IndexName", valueKind: "string" },
+        { canonicalName: "Username", valueKind: "string" },
+        { canonicalName: "Password", valueKind: "string", preserveWhitespace: true }
+    ],
+    NewRelic: [
+        ...DIRECT_VENDOR_CONFIG_FIELDS,
+        { canonicalName: "LicenseKey", valueKind: "string" },
+        { canonicalName: "ApiKey", valueKind: "string" }
+    ],
+    Webhook: [
+        ...EXPANDED_HTTP_CONFIG_FIELDS,
+        { canonicalName: "Url", valueKind: "string" },
+        { canonicalName: "Secret", valueKind: "string" }
+    ],
+    Kafka: [
+        { canonicalName: "BootstrapServers", valueKind: "string" },
+        { canonicalName: "Topic", valueKind: "string" },
+        { canonicalName: "StaticTags", valueKind: "stringMap" }
+    ],
+    StatsD: statsDExpandedConfigFields(),
+    Netdata: statsDExpandedConfigFields(),
+    DogStatsD: statsDExpandedConfigFields(),
+    Jsonl: [
+        { canonicalName: "FilePath", valueKind: "string" },
+        { canonicalName: "StaticTags", valueKind: "stringMap" }
+    ]
+};
+function statsDExpandedConfigFields() {
+    return [
+        { canonicalName: "Prefix", valueKind: "string" },
+        { canonicalName: "Host", valueKind: "string" },
+        { canonicalName: "Port", valueKind: "number" },
+        { canonicalName: "Tags", valueKind: "stringMap", aliases: ["StaticTags"] }
+    ];
+}
+function rememberExpandedReportingSink(sink, kind, options) {
+    const configuredPath = optionString(options, "configurationSectionPath", "ConfigurationSectionPath").trim();
+    EXPANDED_REPORTING_SINK_BINDINGS.set(sink, {
+        kind,
+        configurationSectionPath: configuredPath || DEFAULT_EXPANDED_REPORTING_SECTION_PATHS[kind],
+        options: cloneExpandedSinkOptionRecord(options)
+    });
+}
+function expandedReportingSinkConstructor(kind) {
+    switch (kind) {
+        case "PrometheusRemoteWrite": return PrometheusRemoteWriteReportingSink;
+        case "CloudWatch": return CloudWatchReportingSink;
+        case "Dynatrace": return DynatraceReportingSink;
+        case "Elasticsearch": return ElasticsearchReportingSink;
+        case "OpenSearch": return OpenSearchReportingSink;
+        case "NewRelic": return NewRelicReportingSink;
+        case "Webhook": return GenericWebhookReportingSink;
+        case "Kafka": return KafkaReportingSink;
+        case "StatsD": return StatsDReportingSink;
+        case "Netdata": return NetdataStatsDReportingSink;
+        case "DogStatsD": return DogStatsDReportingSink;
+        case "Jsonl": return JsonlFileReportingSink;
+    }
+}
+function assertExpandedSinkSupportsConfigurationBinding(sink, kind, sectionPath) {
+    if (sink.constructor === expandedReportingSinkConstructor(kind)) {
+        return;
+    }
+    throw new Error(`${sectionPath} cannot be applied to ${sink.constructor.name || "a custom reporting sink"}; `
+        + "configure the custom sink explicitly in code instead.");
+}
+function assertExpandedSinkExecutableOptions(binding) {
+    if (binding.kind !== "Kafka") {
+        return;
+    }
+    const publishAsync = pickRecordValue(binding.options, "publishAsync", "PublishAsync");
+    if (typeof publishAsync === "function") {
+        return;
+    }
+    throw new Error(`${binding.configurationSectionPath}:PublishAsync is required because TypeScript Kafka reporting is `
+        + "callback-backed; BootstrapServers does not enable native broker delivery.");
+}
+function expandedReportingSinkKindFromName(sinkName) {
+    switch (normalizeConfigKey(sinkName)) {
+        case "prometheusremotewrite": return "PrometheusRemoteWrite";
+        case "cloudwatch": return "CloudWatch";
+        case "dynatrace": return "Dynatrace";
+        case "elasticsearch": return "Elasticsearch";
+        case "opensearch": return "OpenSearch";
+        case "newrelic": return "NewRelic";
+        case "webhook": return "Webhook";
+        case "kafka": return "Kafka";
+        case "statsd": return "StatsD";
+        case "netdatastatsd": return "Netdata";
+        case "dogstatsd": return "DogStatsD";
+        case "jsonl": return "Jsonl";
+        default: return undefined;
+    }
+}
+function cloneExpandedSinkOptionRecord(options) {
+    const clone = { ...options };
+    for (const [key, value] of Object.entries(clone)) {
+        if (isRecord(value)) {
+            clone[key] = { ...value };
+        }
+        else if (Array.isArray(value)) {
+            clone[key] = [...value];
+        }
+    }
+    return clone;
+}
+function createBoundExpandedReportingSink(sourceSink, binding, infraConfig, environment) {
+    const section = readExpandedConfigSection(infraConfig, environment, binding.configurationSectionPath);
+    const options = cloneExpandedSinkOptionRecord(binding.options);
+    if (section.present) {
+        assertExpandedSinkSupportsConfigurationBinding(sourceSink, binding.kind, section.path);
+        const configured = normalizeExpandedConfigValues(binding.kind, section.path, section.configurationValues);
+        const environmentConfigured = normalizeExpandedConfigValues(binding.kind, section.path, section.environmentValues);
+        const normalized = mergeExpandedConfigSources(binding.kind, configured, environmentConfigured);
+        applyMissingExpandedConfigOptions(binding.kind, options, binding.options, normalized);
+        prepareExpandedCredentialOptions(binding.kind, options, {
+            explicit: binding.options,
+            environment: environmentConfigured,
+            configuration: configured
+        });
+        validateBoundExpandedConfig(binding.kind, options, section.path);
+    }
+    switch (binding.kind) {
+        case "PrometheusRemoteWrite":
+            return new PrometheusRemoteWriteReportingSink(options);
+        case "CloudWatch":
+            return new CloudWatchReportingSink(options);
+        case "Dynatrace":
+            return new DynatraceReportingSink(options);
+        case "Elasticsearch":
+            return new ElasticsearchReportingSink(options);
+        case "OpenSearch":
+            return new OpenSearchReportingSink(options);
+        case "NewRelic":
+            return new NewRelicReportingSink(options);
+        case "Webhook":
+            return new GenericWebhookReportingSink(options);
+        case "Kafka":
+            return new KafkaReportingSink(options);
+        case "StatsD":
+            return new StatsDReportingSink(options);
+        case "Netdata":
+            return new NetdataStatsDReportingSink(options);
+        case "DogStatsD":
+            return new DogStatsDReportingSink(options);
+        case "Jsonl":
+            return new JsonlFileReportingSink(options);
+    }
+}
+function readExpandedConfigSection(infraConfig, environment, configuredPath) {
+    const pathSegments = splitExpandedConfigPath(configuredPath);
+    const diagnosticPath = pathSegments.join(":");
+    const configurationValues = {};
+    const environmentValues = {};
+    let present = false;
+    const visitConfig = (record, consumed) => {
+        for (const [rawKey, rawValue] of Object.entries(record)) {
+            const candidate = [...consumed, ...splitExpandedConfigPath(rawKey)];
+            if (!expandedConfigPathStartsWith(candidate, pathSegments) &&
+                !expandedConfigPathStartsWith(pathSegments, candidate)) {
+                continue;
+            }
+            if (expandedConfigPathEquals(candidate, pathSegments)) {
+                present = true;
+                if (isRecord(rawValue)) {
+                    mergeExpandedConfigRecords(configurationValues, rawValue);
+                }
+                continue;
+            }
+            if (candidate.length < pathSegments.length) {
+                if (isRecord(rawValue)) {
+                    visitConfig(rawValue, candidate);
+                }
+                continue;
+            }
+            if (expandedConfigPathStartsWith(candidate, pathSegments)) {
+                present = true;
+                setExpandedConfigTail(configurationValues, candidate.slice(pathSegments.length), rawValue);
+            }
+        }
+    };
+    if (isRecord(infraConfig)) {
+        visitConfig(infraConfig, []);
+    }
+    for (const [rawKey, rawValue] of Object.entries(environment)) {
+        if (rawValue === undefined) {
+            continue;
+        }
+        const candidate = splitExpandedConfigPath(rawKey);
+        if (candidate.length <= pathSegments.length ||
+            !expandedConfigPathStartsWith(candidate, pathSegments)) {
+            continue;
+        }
+        present = true;
+        setExpandedConfigTail(environmentValues, candidate.slice(pathSegments.length), rawValue);
+    }
+    return { path: diagnosticPath, present, configurationValues, environmentValues };
+}
+function splitExpandedConfigPath(value) {
+    return String(value ?? "")
+        .split(/__|[:.]/g)
+        .map((segment) => segment.trim())
+        .filter(Boolean);
+}
+function expandedConfigPathStartsWith(candidate, expectedPrefix) {
+    return candidate.length >= expectedPrefix.length && expectedPrefix.every((segment, index) => normalizeConfigKey(candidate[index]) === normalizeConfigKey(segment));
+}
+function expandedConfigPathEquals(left, right) {
+    return left.length === right.length && expandedConfigPathStartsWith(left, right);
+}
+function setExpandedConfigTail(target, tail, value) {
+    if (!tail.length) {
+        return;
+    }
+    let current = target;
+    for (let index = 0; index < tail.length - 1; index += 1) {
+        const segment = tail[index];
+        const existingKey = Object.keys(current).find((key) => normalizeConfigKey(key) === normalizeConfigKey(segment));
+        const key = existingKey ?? segment;
+        if (!isRecord(current[key])) {
+            current[key] = {};
+        }
+        current = current[key];
+    }
+    const leaf = tail[tail.length - 1];
+    const existingLeaf = Object.keys(current).find((key) => normalizeConfigKey(key) === normalizeConfigKey(leaf));
+    current[existingLeaf ?? leaf] = value;
+}
+function mergeExpandedConfigRecords(target, source) {
+    for (const [rawKey, rawValue] of Object.entries(source)) {
+        const existingKey = Object.keys(target).find((key) => normalizeConfigKey(key) === normalizeConfigKey(rawKey));
+        const key = existingKey ?? rawKey;
+        if (isRecord(target[key]) && isRecord(rawValue)) {
+            mergeExpandedConfigRecords(target[key], rawValue);
+        }
+        else {
+            target[key] = isRecord(rawValue) ? cloneExpandedSinkOptionRecord(rawValue) : rawValue;
+        }
+    }
+}
+function normalizeExpandedConfigValues(kind, sectionPath, values) {
+    const fields = EXPANDED_CONFIG_FIELDS[kind];
+    const normalized = {};
+    const entries = Object.entries(values);
+    for (const [rawKey] of entries) {
+        const field = fields.find((candidate) => [candidate.canonicalName, ...(candidate.aliases ?? [])]
+            .some((name) => normalizeConfigKey(name) === normalizeConfigKey(rawKey)));
+        if (!field) {
+            throw new Error(`${sectionPath}:${rawKey} is not supported.`);
+        }
+    }
+    for (const field of fields) {
+        const namesByPrecedence = [...(field.aliases ?? []), field.canonicalName];
+        let selectedValue;
+        let selected = false;
+        for (const name of namesByPrecedence) {
+            const matchingEntries = entries.filter(([rawKey]) => normalizeConfigKey(rawKey) === normalizeConfigKey(name));
+            if (matchingEntries.length > 1) {
+                throw new Error(`${sectionPath}:${name} is configured more than once.`);
+            }
+            if (matchingEntries.length === 0) {
+                continue;
+            }
+            const [rawKey, rawValue] = matchingEntries[0];
+            const value = normalizeExpandedConfigValue(rawValue, field, `${sectionPath}:${rawKey}`);
+            selectedValue = field.valueKind === "stringMap" && selected &&
+                isRecord(selectedValue) && isRecord(value)
+                ? { ...selectedValue, ...value }
+                : value;
+            selected = true;
+        }
+        if (selected) {
+            normalized[field.canonicalName] = selectedValue;
+        }
+    }
+    return normalized;
+}
+function normalizeExpandedConfigValue(value, field, path) {
+    if (field.valueKind === "string") {
+        if (typeof value !== "string") {
+            throw new Error(`${path} must be a string.`);
+        }
+        return field.preserveWhitespace ? value : value.trim();
+    }
+    if (field.valueKind === "number") {
+        if (typeof value === "boolean" || value == null ||
+            (typeof value !== "number" && typeof value !== "string")) {
+            throw new Error(`${path} must be a finite number.`);
+        }
+        const parsed = typeof value === "number" ? value : Number(value.trim());
+        if (!Number.isFinite(parsed)) {
+            throw new Error(`${path} must be a finite number.`);
+        }
+        return parsed;
+    }
+    if (!isRecord(value)) {
+        throw new Error(`${path} must be an object of string values.`);
+    }
+    const normalizedMap = {};
+    for (const [mapKey, mapValue] of Object.entries(value)) {
+        if (typeof mapValue !== "string") {
+            throw new Error(`${path}:${mapKey} must be a string value.`);
+        }
+        normalizedMap[mapKey] = mapValue;
+    }
+    return normalizedMap;
+}
+function mergeExpandedConfigSources(kind, configured, environment) {
+    const merged = cloneExpandedSinkOptionRecord(configured);
+    const clearedSemanticGroups = new Set();
+    for (const [canonicalName, value] of Object.entries(environment)) {
+        const precedenceGroup = expandedOptionPrecedenceGroup(kind, canonicalName);
+        const groupIdentity = precedenceGroup
+            .map((name) => normalizeConfigKey(name))
+            .sort()
+            .join("|");
+        const lowerPriorityMap = precedenceGroup.length === 1 && isRecord(merged[canonicalName])
+            ? merged[canonicalName]
+            : undefined;
+        if (precedenceGroup.length > 1 && !clearedSemanticGroups.has(groupIdentity)) {
+            for (const existingName of Object.keys(merged)) {
+                if (precedenceGroup.some((candidate) => normalizeConfigKey(candidate) === normalizeConfigKey(existingName))) {
+                    delete merged[existingName];
+                }
+            }
+            clearedSemanticGroups.add(groupIdentity);
+        }
+        merged[canonicalName] = lowerPriorityMap && isRecord(value)
+            ? { ...lowerPriorityMap, ...value }
+            : isRecord(value)
+                ? { ...value }
+                : value;
+    }
+    return merged;
+}
+function applyMissingExpandedConfigOptions(kind, target, explicitOptions, configured) {
+    for (const [canonicalName, value] of Object.entries(configured)) {
+        if (hasExplicitExpandedOption(kind, explicitOptions, canonicalName)) {
+            continue;
+        }
+        target[canonicalName] = isRecord(value) ? { ...value } : value;
+    }
+}
+function hasExplicitExpandedOption(kind, options, canonicalName) {
+    const aliases = expandedOptionPrecedenceGroup(kind, canonicalName);
+    return Object.entries(options).some(([key, value]) => value !== undefined && aliases.some((alias) => normalizeConfigKey(alias) === normalizeConfigKey(key)));
+}
+function expandedOptionPrecedenceGroup(kind, canonicalName) {
+    if (canonicalName === "TimeoutSeconds" || canonicalName === "TimeoutMs") {
+        return ["TimeoutSeconds", "TimeoutMs"];
+    }
+    if ((canonicalName === "BaseUrl" || canonicalName === "EndpointUrl") && kind === "CloudWatch") {
+        return ["BaseUrl", "EndpointUrl"];
+    }
+    if ((canonicalName === "BaseUrl" || canonicalName === "Url") && kind === "Webhook") {
+        return ["BaseUrl", "Url"];
+    }
+    if ((canonicalName === "LicenseKey" || canonicalName === "ApiKey") && kind === "NewRelic") {
+        return ["LicenseKey", "ApiKey"];
+    }
+    if ((canonicalName === "EndpointPath" || canonicalName === "IndexName") &&
+        (kind === "Elasticsearch" || kind === "OpenSearch")) {
+        return ["EndpointPath", "IndexName"];
+    }
+    return [canonicalName];
+}
+function prepareExpandedCredentialOptions(kind, options, sources) {
+    let headers = normalizeStringMap(optionRecord(options, "headers", "Headers"));
+    const headerName = expandedCredentialHeaderName(kind);
+    const headerSourceRank = headerName
+        ? expandedCredentialHeaderSourceRank(sources, headerName)
+        : 0;
+    const credentialSourceRank = expandedCredentialSourceRank(kind, sources);
+    if (headerSourceRank > credentialSourceRank) {
+        deleteExpandedCredentialOptions(kind, options);
+    }
+    const credentialMustReplaceHeader = credentialSourceRank > headerSourceRank;
+    if (kind === "Elasticsearch") {
+        const apiKey = optionString(options, "apiKey", "ApiKey").trim();
+        if (apiKey && (credentialMustReplaceHeader || !hasCaseInsensitiveHeader(headers, "Authorization"))) {
+            headers = mergeProtocolHeaders(headers, { Authorization: `ApiKey ${apiKey}` });
+        }
+    }
+    else if (kind === "OpenSearch") {
+        const username = optionString(options, "username", "Username").trim();
+        const password = optionString(options, "password", "Password");
+        if ((username || password) &&
+            (credentialMustReplaceHeader || !hasCaseInsensitiveHeader(headers, "Authorization"))) {
+            headers = mergeProtocolHeaders(headers, {
+                Authorization: `Basic ${Buffer.from(`${username}:${password}`, "utf8").toString("base64")}`
+            });
+        }
+    }
+    else if (kind === "Webhook") {
+        const secret = optionString(options, "secret", "Secret").trim();
+        const url = optionString(options, "url", "Url").trim();
+        if (url) {
+            options.__loadstrikeExactUrl = url;
+        }
+        if (secret && (credentialMustReplaceHeader || !hasCaseInsensitiveHeader(headers, "Authorization"))) {
+            headers = mergeProtocolHeaders(headers, { Authorization: `LoadStrike ${secret}` });
+        }
+    }
+    if (Object.keys(headers).length > 0) {
+        options.Headers = headers;
+        delete options.headers;
+    }
+}
+function expandedCredentialHeaderName(kind) {
+    if (kind === "PrometheusRemoteWrite" || kind === "Dynatrace" ||
+        kind === "Elasticsearch" || kind === "OpenSearch" || kind === "Webhook") {
+        return "Authorization";
+    }
+    return kind === "NewRelic" ? "Api-Key" : undefined;
+}
+function expandedCredentialHeaderSourceRank(sources, headerName) {
+    return expandedSourceRank(sources, (source) => {
+        const headers = normalizeStringMap(optionRecord(source, "headers", "Headers"));
+        return Object.entries(headers).some(([name, value]) => name.toLowerCase() === headerName.toLowerCase() && value.trim().length > 0);
+    });
+}
+function expandedCredentialSourceRank(kind, sources) {
+    return expandedSourceRank(sources, (source) => expandedSourceHasCredential(kind, source));
+}
+function expandedSourceRank(sources, predicate) {
+    if (predicate(sources.explicit))
+        return 3;
+    if (predicate(sources.environment))
+        return 2;
+    if (predicate(sources.configuration))
+        return 1;
+    return 0;
+}
+function expandedSourceHasCredential(kind, source) {
+    switch (kind) {
+        case "PrometheusRemoteWrite":
+            return optionString(source, "bearerToken", "BearerToken").trim().length > 0;
+        case "Dynatrace":
+            return optionString(source, "apiToken", "ApiToken").trim().length > 0;
+        case "Elasticsearch":
+            return optionString(source, "apiKey", "ApiKey").trim().length > 0;
+        case "OpenSearch":
+            return optionString(source, "username", "Username").trim().length > 0
+                || optionString(source, "password", "Password").length > 0;
+        case "NewRelic":
+            return optionString(source, "licenseKey", "LicenseKey", "apiKey", "ApiKey").trim().length > 0;
+        case "Webhook":
+            return optionString(source, "secret", "Secret").trim().length > 0;
+        default:
+            return false;
+    }
+}
+function deleteExpandedCredentialOptions(kind, options) {
+    const names = (() => {
+        switch (kind) {
+            case "PrometheusRemoteWrite": return ["BearerToken"];
+            case "Dynatrace": return ["ApiToken"];
+            case "Elasticsearch": return ["ApiKey"];
+            case "OpenSearch": return ["Username", "Password"];
+            case "NewRelic": return ["LicenseKey", "ApiKey"];
+            case "Webhook": return ["Secret"];
+            default: return [];
+        }
+    })();
+    for (const key of Object.keys(options)) {
+        if (names.some((name) => normalizeConfigKey(name) === normalizeConfigKey(key))) {
+            delete options[key];
+        }
+    }
+}
+function validateBoundExpandedConfig(kind, options, sectionPath) {
+    const requireString = (name, ...aliases) => {
+        const value = optionString(options, name, ...aliases).trim();
+        if (!value) {
+            throw new Error(`${sectionPath}:${name} is required.`);
+        }
+        return value;
+    };
+    const validateUrl = (name, value) => {
+        try {
+            const parsed = new URL(value);
+            if ((parsed.protocol !== "http:" && parsed.protocol !== "https:") ||
+                !parsed.hostname || parsed.username || parsed.password) {
+                throw new Error("invalid");
+            }
+        }
+        catch {
+            throw new Error(`${sectionPath}:${name} must be an absolute HTTP or HTTPS URL.`);
+        }
+    };
+    if (kind === "PrometheusRemoteWrite" || kind === "Dynatrace" ||
+        kind === "Elasticsearch" || kind === "OpenSearch" || kind === "NewRelic") {
+        validateUrl("BaseUrl", requireString("BaseUrl"));
+    }
+    if (kind === "CloudWatch") {
+        const endpointPath = optionString(options, "endpointPath", "EndpointPath").trim();
+        if (endpointPath && normalizePath(endpointPath) !== "/") {
+            throw new Error(`${sectionPath}:EndpointPath is not supported for CloudWatch; `
+                + "include any required path in EndpointUrl.");
+        }
+        const endpoint = optionString(options, "endpointUrl", "EndpointUrl", "baseUrl", "BaseUrl").trim();
+        if (endpoint) {
+            const endpointName = optionString(options, "endpointUrl", "EndpointUrl").trim()
+                ? "EndpointUrl"
+                : "BaseUrl";
+            validateUrl(endpointName, endpoint);
+        }
+        requireString("Region");
+        requireString("AccessKeyId");
+        requireString("SecretAccessKey");
+    }
+    if (kind === "Dynatrace" &&
+        !optionString(options, "apiToken", "ApiToken").trim() &&
+        !hasCaseInsensitiveHeader(normalizeStringMap(optionRecord(options, "headers", "Headers")), "Authorization")) {
+        throw new Error(`${sectionPath}:ApiToken is required.`);
+    }
+    if (kind === "NewRelic" &&
+        !optionString(options, "licenseKey", "LicenseKey", "apiKey", "ApiKey").trim() &&
+        !hasCaseInsensitiveHeader(normalizeStringMap(optionRecord(options, "headers", "Headers")), "Api-Key")) {
+        throw new Error(`${sectionPath}:LicenseKey is required.`);
+    }
+    if (kind === "Elasticsearch" || kind === "OpenSearch") {
+        const endpointPath = optionString(options, "endpointPath", "EndpointPath").trim();
+        if (!endpointPath) {
+            const rawIndexName = pickRecordValue(options, "indexName", "IndexName");
+            const indexName = rawIndexName === undefined
+                ? "loadstrike-events"
+                : typeof rawIndexName === "string"
+                    ? rawIndexName.trim()
+                    : "";
+            requireValidSearchIndexName(indexName, `${sectionPath}:IndexName`);
+        }
+    }
+    if (kind === "OpenSearch") {
+        const username = optionString(options, "username", "Username").trim();
+        const password = optionString(options, "password", "Password");
+        if (username && !password) {
+            throw new Error(`${sectionPath}:Password is required when Username is configured.`);
+        }
+        if (password && !username) {
+            throw new Error(`${sectionPath}:Username is required when Password is configured.`);
+        }
+    }
+    if (kind === "Webhook") {
+        const url = optionString(options, "url", "Url").trim();
+        if (url) {
+            validateUrl("Url", url);
+        }
+        else {
+            validateUrl("BaseUrl", requireString("BaseUrl"));
+        }
+    }
+    if (kind === "StatsD" || kind === "Netdata" || kind === "DogStatsD") {
+        const configuredPort = pickRecordValue(options, "port", "Port");
+        if (configuredPort !== undefined) {
+            const port = Number(configuredPort);
+            if (!Number.isInteger(port) || port < 1 || port > 65535) {
+                throw new Error(`${sectionPath}:Port must be an integer between 1 and 65535.`);
+            }
+        }
+    }
+}
 function resolveConfigSection(source, path) {
     const trimmedPath = String(path ?? "").trim();
     if (!trimmedPath) {
@@ -3323,6 +4540,73 @@ function resolveTimeoutMs(timeoutSeconds, timeoutMs) {
     }
     return 30000;
 }
+function reportingIntervalMilliseconds(seconds) {
+    if (seconds === undefined) {
+        return undefined;
+    }
+    if (!Number.isFinite(seconds) || seconds <= 0) {
+        throw new Error("ReportingIntervalSeconds must be a positive finite number.");
+    }
+    const milliseconds = Math.round(seconds * 1000);
+    if (!Number.isSafeInteger(milliseconds) || milliseconds <= 0) {
+        throw new Error("ReportingIntervalSeconds is outside the supported range.");
+    }
+    return milliseconds;
+}
+function positiveIntervalMilliseconds(previous, current) {
+    if (!previous || !Number.isFinite(previous.getTime()) || !Number.isFinite(current.getTime())) {
+        return 1;
+    }
+    return Math.max(Math.round(current.getTime() - previous.getTime()), 1);
+}
+function requireHttpReportingUrl(value, fieldName) {
+    let parsed;
+    try {
+        parsed = new URL(value);
+    }
+    catch {
+        throw new Error(`${fieldName} must be an absolute HTTP or HTTPS URL.`);
+    }
+    if ((parsed.protocol !== "http:" && parsed.protocol !== "https:") || !parsed.hostname) {
+        throw new Error(`${fieldName} must be an absolute HTTP or HTTPS URL.`);
+    }
+    if (parsed.username || parsed.password) {
+        throw new Error(`${fieldName} must not contain credentials.`);
+    }
+}
+function hasCaseInsensitiveHeader(headers, expectedName) {
+    const expected = expectedName.toLowerCase();
+    return Object.entries(headers).some(([name, value]) => name.toLowerCase() === expected && value.trim().length > 0);
+}
+function normalizeProtocolHeaders(headers) {
+    return mergeProtocolHeaders({}, headers);
+}
+function mergeProtocolHeaders(headers, requiredHeaders) {
+    const merged = {};
+    const namesByLowerCase = new Map();
+    for (const source of [headers, requiredHeaders]) {
+        for (const [name, value] of Object.entries(source)) {
+            const normalized = name.toLowerCase();
+            const previousName = namesByLowerCase.get(normalized);
+            if (previousName !== undefined) {
+                delete merged[previousName];
+            }
+            merged[name] = String(value);
+            namesByLowerCase.set(normalized, name);
+        }
+    }
+    return merged;
+}
+function isCloudWatchProtocolHeader(name) {
+    const normalized = name.toLowerCase();
+    return normalized === "authorization"
+        || normalized === "host"
+        || normalized === "content-type"
+        || normalized === "content-length"
+        || normalized === "user-agent"
+        || normalized.startsWith("x-amz-")
+        || normalized.startsWith("amz-sdk-");
+}
 function toUnixNanoseconds(value) {
     return (BigInt(value.getTime()) * 1000000n).toString();
 }
@@ -3565,7 +4849,7 @@ function deepCloneValue(value) {
 function gzipJsonRequestBody(value) {
     return Uint8Array.from(serializeIterationObservationBatchGzipJson(value)).buffer;
 }
-async function postWithTimeout(fetchImpl, url, init, timeoutMs, sinkName) {
+async function postWithTimeout(fetchImpl, url, init, timeoutMs, sinkName, ignoreSuccessfulResponseBody = false) {
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(), Math.max(timeoutMs, 1));
     try {
@@ -3573,12 +4857,27 @@ async function postWithTimeout(fetchImpl, url, init, timeoutMs, sinkName) {
         if (!response.ok) {
             throw new ReportingSinkHttpError(sinkName, response.status, readHttpResponseStatusText(response), readHttpResponseRequestId(response));
         }
+        if (ignoreSuccessfulResponseBody) {
+            disposeResponseBody(response);
+            return "";
+        }
         return await readResponseBodyText(response);
     }
     finally {
         clearTimeout(timer);
     }
 }
+function disposeResponseBody(response) {
+    try {
+        const cancellation = response.body?.cancel();
+        if (cancellation && typeof cancellation.catch === "function") {
+            void cancellation.catch(() => undefined);
+        }
+    }
+    catch {
+        // A successful write must not be reclassified as failed because its response body cannot be consumed.
+    }
+}
 async function readResponseBodyText(response) {
     const body = response.body;
     if (body && typeof body.getReader === "function") {