@loadstrike/loadstrike-sdk 1.0.31601 → 1.0.32601

package/README.md

@@ -11,7 +11,9 @@ LoadStrike is a developer-first load testing SDK for Node.js applications, servi
 - Split a single load profile across weighted scenario mixes.
 - Generate local reports and, on Enterprise, publish observability data to supported sinks.
 
-Built-in transport coverage includes HTTP, Kafka, RabbitMQ, NATS, Redis Streams, Azure Event Hubs, Push Diffusion, and delegate-based custom streams. Local report output supports HTML, Markdown, TXT, and CSV, and Enterprise can publish to InfluxDB, TimescaleDB, Grafana Loki, Datadog, Splunk HEC, OpenTelemetry Collector, and the expanded built-in sink family.
+Built-in transport coverage includes HTTP, Kafka, RabbitMQ, NATS, Redis Streams, Azure Event Hubs, Push Diffusion, and delegate-based custom streams. Local report output supports HTML, Markdown, TXT, and CSV, and Enterprise can publish to InfluxDB, TimescaleDB, Grafana Loki, Datadog, Splunk HEC, OpenTelemetry Collector, and the other supported sinks described below.
+
+gRPC endpoints require a matching synchronous or asynchronous Produce or Consume delegate. Without one, initialization fails with `Native gRPC execution is not available in this SDK version. Provide the endpoint Produce/Consume delegate instead.` On Node.js, WebSocket supports native or delegate-backed Produce and Consume; a matching delegate takes precedence over `NativeClient`.
 
 ## Requirements
 
@@ -78,7 +80,17 @@ If a fail-mode runtime policy callback fails after an attempt begins, the stream
 
 Portal reporting sends compressed batches, while the JSONL and generic webhook sinks preserve the canonical observation records. Custom sinks can opt in with `saveIterationBatch` or `SaveIterationBatch` while keeping all existing aggregate lifecycle callbacks unchanged. Batches flush every five seconds; the defaults and the portal-compatible common shape are 50,000 observations or 8 MiB before compression. Runs without a portal sink may select the documented larger limits. Capture and sink queues are memory bounded; buffer pressure, a single record that cannot fit a batch, and sink pressure drop only the affected reporting observations with explicit warnings instead of changing application failures. Metric-only destinations disclose their reduced observation shape. The final observation flush and optional stream-completion callback finish before `saveRunResult` or `SaveRunResult`.
 
-Every reporting-sink callback—including initialization, start, realtime statistics and metrics, final statistics and metrics, raw batches, completion markers, stop, and dispose—is attempted once and then retried up to three times by default, after 250 ms, 500 ms, and 1 second. Set `sinkRetryCount` and `sinkRetryBackoffMs`, or the matching Pascal-case configuration keys, to select a bounded policy of zero through 100 retries. A recovered callback adds no final sink error or delivery-failed warning. Only an exhausted raw-observation delivery counts as sink observation loss; other exhausted callbacks are reported against that sink without failing the workload. Custom sinks have at-least-once delivery semantics and should deduplicate replay by stable batch or observation identity. Stop and dispose remain best-effort cleanup, and an exhausted stop callback does not prevent dispose. Sanitized nested error details stay in the local run log rather than generator warnings, portable results, portal payloads, or HTML reports.
+Every reporting-sink callback—including initialization, start, realtime statistics and metrics, final statistics and metrics, raw batches, completion markers, stop, and dispose—is attempted once and then retried up to three times by default, after 250 ms, 500 ms, and 1 second. Set `sinkRetryCount` and `sinkRetryBackoffMs`, or the matching Pascal-case configuration keys, to select a bounded policy of zero through 100 retries. A recovered callback adds no final sink error or delivery-failed warning. Only an exhausted raw-observation delivery counts as sink observation loss; other exhausted callbacks are reported against that sink without failing the workload. Custom sinks may receive the same delivery more than once and should handle repeats safely. Stop and dispose remain best-effort cleanup, and an exhausted stop callback does not prevent dispose. Sanitized nested error details stay in the local run log rather than generator warnings, portable results, portal payloads, or HTML reports.
+
+Prometheus Remote Write, CloudWatch, Dynatrace, and New Relic publish their provider-specific metric protocols and apply the shared [metric input limits](../README.md#metric-input-limits).
+
+`ElasticsearchReportingSink` and `OpenSearchReportingSink` send one JSON document per reporting call. Their public options include `IndexName`, which defaults to `loadstrike-events` and produces `/{IndexName}/_doc`. An explicit `EndpointPath` remains the compatibility override and takes precedence. Elasticsearch `ApiKey` and OpenSearch `Username`/`Password` produce the matching `Authorization` header, while an explicit authorization header remains authoritative.
+
+For direct index routing, `IndexName` must be nonblank lowercase text, at most 255 UTF-8 bytes, not `.` or `..`, and cannot start with `-`, `_`, or `+`. It rejects `\ / * ? " < > |`, ASCII space, comma, `#`, `:`, control characters, and malformed Unicode. Validation identifies the affected option or full configuration path without echoing the rejected value. An explicit `EndpointPath` makes `IndexName` dormant, so the unused name is not validated.
+
+Expanded infra config fills only missing values for sinks already selected in code. Canonical `LoadStrike:ReportingSinks:*` keys include HTTP `BaseUrl`, `EndpointPath`, `TimeoutSeconds`, `Headers`, and `StaticTags`; provider credentials and namespace/region fields; Webhook `Url`/`Secret`; Kafka `BootstrapServers`/`Topic`/`StaticTags`; StatsD-family `Prefix`/`Host`/`Port`/`Tags`; and JSONL `FilePath`. Explicit constructor values win and dormant sections are ignored. Unknown selected keys retain their complete path in the diagnostic, while API keys, secrets, tokens, passwords, and sensitive header values are redacted.
+
+`GenericWebhook` intentionally sends generic LoadStrike JSON, including gzip-compressed observation batches where applicable. It does not translate that body to a vendor metric protocol. When migrating an old generic metrics URL, use `GenericWebhookReportingSink` only if the receiver accepts the generic contract; otherwise choose the matching direct vendor sink.
 
 Portal trend p50, p75, p95, and p99 values are calculated cumulatively from every final bombing-phase outcome received for that scenario and run. Separate successful and failed distributions remain available for diagnosis; SDK-calculated percentile fields are not sent as the authoritative portal or observation-capable sink result.
 

package/dist/cjs/internal/prometheus-remote-write.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodePrometheusRemoteWrite = encodePrometheusRemoteWrite;
+const protobufjs_1 = __importDefault(require("protobufjs"));
+const vendor_metric_payloads_js_1 = require("./vendor-metric-payloads.js");
+const PrometheusLabel = new protobufjs_1.default.Type("Label")
+    .add(new protobufjs_1.default.Field("name", 1, "string"))
+    .add(new protobufjs_1.default.Field("value", 2, "string"));
+const PrometheusSample = new protobufjs_1.default.Type("Sample")
+    .add(new protobufjs_1.default.Field("value", 1, "double"))
+    .add(new protobufjs_1.default.Field("timestamp", 2, "int64"));
+const PrometheusTimeSeries = new protobufjs_1.default.Type("TimeSeries")
+    .add(new protobufjs_1.default.Field("labels", 1, "Label", "repeated"))
+    .add(new protobufjs_1.default.Field("samples", 2, "Sample", "repeated"))
+    .add(PrometheusLabel)
+    .add(PrometheusSample);
+const PrometheusWriteRequest = new protobufjs_1.default.Type("WriteRequest")
+    .add(new protobufjs_1.default.Field("timeseries", 1, "TimeSeries", "repeated"))
+    .add(PrometheusTimeSeries);
+function encodePrometheusRemoteWrite(points, staticLabels = {}) {
+    const prepared = (0, vendor_metric_payloads_js_1.prepareProtocolMetricPoints)("prometheus", points, staticLabels);
+    const timeseries = prepared.map((point) => {
+        const labels = [["__name__", point.metricName], ...point.attributes];
+        labels.sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0);
+        return {
+            labels: labels.map(([name, value]) => ({ name, value })),
+            samples: [{ value: point.value, timestamp: point.occurredUtc.getTime() }]
+        };
+    });
+    return {
+        contentType: "application/x-protobuf",
+        body: PrometheusWriteRequest.encode({ timeseries }).finish()
+    };
+}

package/dist/cjs/internal/reporting-sink-http-error.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReportingSinkHttpError = void 0;
+class ReportingSinkHttpError extends Error {
+    constructor(sinkName, status, statusText, requestId) {
+        const normalizedStatus = Number.isFinite(status) ? Math.max(Math.trunc(status), 0) : 0;
+        super(`${sinkName} write failed with HTTP status ${normalizedStatus}`
+            + (statusText ? ` ${statusText}` : "")
+            + (requestId ? ` (requestId=${requestId})` : "")
+            + ".");
+        this.name = "ReportingSinkHttpError";
+        this.status = normalizedStatus;
+        this.statusText = statusText;
+        this.requestId = requestId;
+    }
+}
+exports.ReportingSinkHttpError = ReportingSinkHttpError;

package/dist/cjs/internal/vendor-metric-payloads.js

@@ -0,0 +1,390 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCloudWatchMetricData = createCloudWatchMetricData;
+exports.encodeDynatraceMetrics = encodeDynatraceMetrics;
+exports.encodeDynatraceMetricBatches = encodeDynatraceMetricBatches;
+exports.encodeNewRelicMetricBatch = encodeNewRelicMetricBatch;
+exports.encodeNewRelicMetricBatches = encodeNewRelicMetricBatches;
+exports.prepareProtocolMetricPoints = prepareProtocolMetricPoints;
+const MAXIMUM_METRIC_NAME_BYTES = 200;
+const MAXIMUM_ATTRIBUTE_KEY_BYTES = 64;
+const MAXIMUM_ATTRIBUTE_VALUE_BYTES = 256;
+const MAXIMUM_DYNATRACE_ATTRIBUTE_VALUE_BYTES = 255;
+const MAXIMUM_ATTRIBUTES = 20;
+const MAXIMUM_ABSOLUTE_VALUE = 1e100;
+const MAXIMUM_SIGNED_INT64 = 9223372036854775807n;
+const RESERVED_ATTRIBUTES = new Set(["scenario", "status", "run_id"]);
+function createCloudWatchMetricData(namespace, points, staticDimensions = {}) {
+    const normalizedNamespace = normalizeCloudWatchNamespace(namespace);
+    const prepared = prepareProtocolMetricPoints("cloudwatch", points, staticDimensions);
+    return {
+        Namespace: normalizedNamespace,
+        MetricData: prepared.map((point) => {
+            const unit = cloudWatchUnit(point.metricKind, point.unitOfMeasure);
+            return {
+                MetricName: point.metricName,
+                Dimensions: point.attributes.map(([Name, Value]) => ({ Name, Value })),
+                Value: point.value,
+                ...(unit ? { Unit: unit } : {}),
+                Timestamp: new Date(point.occurredUtc.getTime())
+            };
+        })
+    };
+}
+function encodeDynatraceMetrics(points, staticDimensions = {}) {
+    const prepared = prepareProtocolMetricPoints("dynatrace", points, staticDimensions);
+    return encodeDynatracePreparedMetrics(prepared);
+}
+function encodeDynatraceMetricBatches(points, staticDimensions = {}, maximumBodyBytesExclusive = 1000000) {
+    const prepared = prepareProtocolMetricPoints("dynatrace", points, staticDimensions);
+    return encodeTextBatches("dynatrace", "text/plain; charset=utf-8", prepared.map((point) => dynatraceMetricLine(point)), "", "", "\n", maximumBodyBytesExclusive);
+}
+function encodeNewRelicMetricBatch(points, staticAttributes = {}) {
+    const prepared = prepareProtocolMetricPoints("newrelic", points, staticAttributes);
+    return encodeNewRelicPreparedMetrics(prepared);
+}
+function encodeNewRelicMetricBatches(points, staticAttributes = {}, maximumBodyBytesExclusive = 1000000) {
+    const prepared = prepareProtocolMetricPoints("newrelic", points, staticAttributes);
+    return encodeTextBatches("newrelic", "application/json", prepared.map((point) => newRelicMetricJson(point)), '[{"metrics":[', "]}]", ",", maximumBodyBytesExclusive);
+}
+function prepareProtocolMetricPoints(sink, points, staticAttributes = {}) {
+    if (!Array.isArray(points) || points.length === 0) {
+        throw protocolError(sink, "metric batch");
+    }
+    if (!isPlainRecord(staticAttributes)) {
+        throw protocolError(sink, "attribute collection");
+    }
+    // Validate and copy every point before any protocol bytes or DTOs are emitted.
+    const prepared = [];
+    for (let index = 0; index < points.length; index += 1) {
+        prepared.push(prepareProtocolMetricPoint(sink, points[index], staticAttributes));
+    }
+    return prepared;
+}
+function prepareProtocolMetricPoint(sink, point, staticAttributes) {
+    if (!point || typeof point !== "object") {
+        throw protocolError(sink, "metric point");
+    }
+    const metricKind = normalizeMetricKind(sink, point.metricKind);
+    if (!(point.occurredUtc instanceof Date) || !Number.isFinite(point.occurredUtc.getTime())) {
+        throw protocolError(sink, "timestamp");
+    }
+    if (!Number.isFinite(point.value) || point.value < -MAXIMUM_ABSOLUTE_VALUE || point.value > MAXIMUM_ABSOLUTE_VALUE) {
+        throw protocolError(sink, "value");
+    }
+    const intervalMs = metricKind === "count"
+        ? normalizePositiveInt64(sink, point.intervalMs)
+        : undefined;
+    if (metricKind === "gauge" && point.intervalMs !== undefined) {
+        throw protocolError(sink, "interval");
+    }
+    const rawUnitOfMeasure = point.unitOfMeasure;
+    let unitOfMeasure;
+    if (rawUnitOfMeasure !== undefined && rawUnitOfMeasure !== null) {
+        if (typeof rawUnitOfMeasure !== "string" || !isWellFormedUnicode(rawUnitOfMeasure)) {
+            throw protocolError(sink, "unit of measure");
+        }
+        unitOfMeasure = rawUnitOfMeasure;
+    }
+    const metricName = normalizeMetricName(sink, point.metricName);
+    const authoritative = [
+        ["scenario", validateAuthoritativeValue(sink, "scenario", point.scenario)],
+        ["status", validateAuthoritativeValue(sink, "status", point.status)]
+    ];
+    if (point.runId !== undefined) {
+        authoritative.push(["run_id", validateAuthoritativeValue(sink, "run_id", point.runId)]);
+    }
+    const emptyValuesAllowed = sink === "prometheus" || sink === "newrelic";
+    const normalizedStatic = new Map();
+    for (const [rawKey, rawValue] of Object.entries(staticAttributes)) {
+        const key = normalizeAttributeKey(sink, rawKey);
+        if (RESERVED_ATTRIBUTES.has(key)) {
+            throw protocolError(sink, key);
+        }
+        if (sink === "prometheus" && key === "__name__") {
+            throw protocolError(sink, "attribute key");
+        }
+        if (normalizedStatic.has(key)) {
+            throw protocolError(sink, "attribute key collision");
+        }
+        if (typeof rawValue !== "string" || !isWellFormedUnicode(rawValue) ||
+            (!emptyValuesAllowed && rawValue.length === 0) ||
+            utf8Length(rawValue) > maximumAttributeValueBytes(sink) ||
+            (sink === "dynatrace" && /[\r\n]/.test(rawValue)) ||
+            (sink === "cloudwatch" && !isCloudWatchDimensionValue(rawValue))) {
+            throw protocolError(sink, "attribute value");
+        }
+        normalizedStatic.set(key, rawValue);
+    }
+    if (authoritative.length + normalizedStatic.size > MAXIMUM_ATTRIBUTES) {
+        throw protocolError(sink, "attribute count");
+    }
+    const attributes = [...authoritative, ...normalizedStatic.entries()]
+        .sort(([left], [right]) => compareOrdinal(left, right));
+    return {
+        metricName,
+        metricKind,
+        occurredUtc: new Date(point.occurredUtc.getTime()),
+        value: point.value,
+        unitOfMeasure,
+        intervalMs,
+        attributes
+    };
+}
+function encodeDynatracePreparedMetrics(prepared) {
+    return {
+        contentType: "text/plain; charset=utf-8",
+        body: new TextEncoder().encode(prepared.map((point) => dynatraceMetricLine(point)).join("\n"))
+    };
+}
+function dynatraceMetricLine(point) {
+    const dimensions = point.attributes
+        .map(([key, value]) => `${key}="${escapeDynatraceDimensionValue(value)}"`)
+        .join(",");
+    const identity = dimensions.length > 0 ? `${point.metricName},${dimensions}` : point.metricName;
+    const payload = point.metricKind === "count"
+        ? `count,delta=${formatFiniteNumber(point.value)}`
+        : `gauge,${formatFiniteNumber(point.value)}`;
+    return `${identity} ${payload} ${point.occurredUtc.getTime()}`;
+}
+function encodeNewRelicPreparedMetrics(prepared) {
+    return {
+        contentType: "application/json",
+        body: new TextEncoder().encode(`[{"metrics":[${prepared.map((point) => newRelicMetricJson(point)).join(",")}]}]`)
+    };
+}
+function newRelicMetricJson(point) {
+    const properties = [
+        `"name":${JSON.stringify(point.metricName)}`,
+        `"type":${JSON.stringify(point.metricKind)}`,
+        `"value":${JSON.stringify(point.value)}`,
+        `"timestamp":${point.occurredUtc.getTime()}`
+    ];
+    if (point.metricKind === "count") {
+        if (point.intervalMs === undefined) {
+            throw protocolError("newrelic", "interval");
+        }
+        properties.push(`"interval.ms":${point.intervalMs.toString()}`);
+    }
+    properties.push(`"attributes":${JSON.stringify(Object.fromEntries(point.attributes))}`);
+    return `{${properties.join(",")}}`;
+}
+function encodeTextBatches(sink, contentType, items, prefix, suffix, separator, maximumBodyBytesExclusive) {
+    if (!Number.isSafeInteger(maximumBodyBytesExclusive) || maximumBodyBytesExclusive <= 0) {
+        throw protocolError(sink, "payload size limit");
+    }
+    const prefixBytes = utf8Length(prefix);
+    const suffixBytes = utf8Length(suffix);
+    const separatorBytes = utf8Length(separator);
+    const batches = [];
+    let current = [];
+    let currentBytes = prefixBytes + suffixBytes;
+    for (const item of items) {
+        const itemBytes = utf8Length(item);
+        if (prefixBytes + itemBytes + suffixBytes >= maximumBodyBytesExclusive) {
+            throw protocolError(sink, "payload size");
+        }
+        const candidateBytes = currentBytes + (current.length > 0 ? separatorBytes : 0) + itemBytes;
+        if (candidateBytes >= maximumBodyBytesExclusive) {
+            batches.push(current);
+            current = [item];
+            currentBytes = prefixBytes + itemBytes + suffixBytes;
+        }
+        else {
+            current.push(item);
+            currentBytes = candidateBytes;
+        }
+    }
+    if (current.length > 0) {
+        batches.push(current);
+    }
+    const encoder = new TextEncoder();
+    return batches.map((batch) => ({
+        contentType,
+        body: encoder.encode(`${prefix}${batch.join(separator)}${suffix}`)
+    }));
+}
+function normalizePositiveInt64(sink, value) {
+    let normalized;
+    if (typeof value === "bigint") {
+        normalized = value;
+    }
+    else if (typeof value === "number" && Number.isSafeInteger(value)) {
+        normalized = BigInt(value);
+    }
+    else {
+        throw protocolError(sink, "interval");
+    }
+    if (normalized <= 0n || normalized > MAXIMUM_SIGNED_INT64) {
+        throw protocolError(sink, "interval");
+    }
+    return normalized;
+}
+function normalizeMetricName(sink, value) {
+    if (typeof value !== "string" || !isWellFormedUnicode(value) || value.trim().length === 0) {
+        throw protocolError(sink, "metric name");
+    }
+    let normalized = sink === "prometheus"
+        ? normalizeAsciiIdentifier(value.trim(), true)
+        : sink === "dynatrace"
+            ? normalizeAsciiIdentifier(value.trim(), false)
+            : value.trim();
+    if (sink === "dynatrace" && utf8Length(normalized) < 3) {
+        normalized = `ls_${normalized}`;
+    }
+    if (normalized.length === 0 || utf8Length(normalized) > MAXIMUM_METRIC_NAME_BYTES) {
+        throw protocolError(sink, "metric name");
+    }
+    return normalized;
+}
+function normalizeMetricKind(sink, value) {
+    if (typeof value !== "string" || !isWellFormedUnicode(value)) {
+        throw protocolError(sink, "metric kind");
+    }
+    let normalized = "";
+    for (const character of value.trim()) {
+        normalized += character >= "A" && character <= "Z"
+            ? String.fromCharCode(character.charCodeAt(0) + 0x20)
+            : character;
+    }
+    if (normalized !== "count" && normalized !== "gauge") {
+        throw protocolError(sink, "metric kind");
+    }
+    return normalized;
+}
+function normalizeAttributeKey(sink, value) {
+    if (typeof value !== "string" || !isWellFormedUnicode(value) || value.trim().length === 0) {
+        throw protocolError(sink, "attribute key");
+    }
+    if (sink === "cloudwatch" && !isPrintableASCII(value)) {
+        throw protocolError(sink, "attribute key");
+    }
+    let normalized;
+    if (sink === "prometheus")
+        normalized = normalizeAsciiIdentifier(value.trim(), false);
+    else if (sink === "dynatrace")
+        normalized = normalizeAsciiIdentifier(value.trim(), false).toLowerCase();
+    else if (sink === "newrelic")
+        normalized = normalizeNewRelicAttributeKey(value.trim());
+    else
+        normalized = value.trim();
+    if (normalized.length === 0 || utf8Length(normalized) > MAXIMUM_ATTRIBUTE_KEY_BYTES) {
+        throw protocolError(sink, "attribute key");
+    }
+    if (sink === "cloudwatch" && !isCloudWatchDimensionName(normalized)) {
+        throw protocolError(sink, "attribute key");
+    }
+    return normalized;
+}
+function normalizeAsciiIdentifier(value, allowColon) {
+    let normalized = "";
+    for (const character of value) {
+        normalized += /[A-Za-z0-9_]/.test(character) || (allowColon && character === ":")
+            ? character
+            : "_";
+    }
+    if (!/^[A-Za-z_]/.test(normalized) && !(allowColon && normalized.startsWith(":"))) {
+        normalized = `_${normalized}`;
+    }
+    return normalized;
+}
+function validateAuthoritativeValue(sink, field, value) {
+    if (typeof value !== "string" || !isWellFormedUnicode(value) ||
+        value.trim().length === 0 || utf8Length(value) > maximumAttributeValueBytes(sink) ||
+        (sink === "dynatrace" && /[\r\n]/.test(value)) ||
+        (sink === "cloudwatch" && !isCloudWatchDimensionValue(value))) {
+        throw protocolError(sink, field);
+    }
+    return value;
+}
+function normalizeCloudWatchNamespace(value) {
+    if (typeof value !== "string" || !isWellFormedUnicode(value)) {
+        throw protocolError("cloudwatch", "namespace");
+    }
+    const normalized = value.trim();
+    if (utf8Length(normalized) < 1 || utf8Length(normalized) > 100 || normalized.startsWith(":")) {
+        throw protocolError("cloudwatch", "namespace");
+    }
+    return normalized;
+}
+function cloudWatchUnit(metricKind, unit) {
+    if (metricKind === "count")
+        return "Count";
+    switch (unit?.trim().toLowerCase()) {
+        case "count":
+        case "counts": return "Count";
+        case "ms":
+        case "millisecond":
+        case "milliseconds": return "Milliseconds";
+        case "byte":
+        case "bytes": return "Bytes";
+        case "s":
+        case "sec":
+        case "seconds":
+        case "second": return "Seconds";
+        default: return "None";
+    }
+}
+function escapeDynatraceDimensionValue(value) {
+    return value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"");
+}
+function formatFiniteNumber(value) {
+    return Object.is(value, -0) ? "0" : String(value);
+}
+function utf8Length(value) {
+    return new TextEncoder().encode(value).byteLength;
+}
+function isWellFormedUnicode(value) {
+    for (let index = 0; index < value.length; index += 1) {
+        const codeUnit = value.charCodeAt(index);
+        if (codeUnit >= 0xd800 && codeUnit <= 0xdbff) {
+            if (index + 1 >= value.length)
+                return false;
+            const next = value.charCodeAt(index + 1);
+            if (next < 0xdc00 || next > 0xdfff)
+                return false;
+            index += 1;
+        }
+        else if (codeUnit >= 0xdc00 && codeUnit <= 0xdfff) {
+            return false;
+        }
+    }
+    return true;
+}
+function isPlainRecord(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        return false;
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}
+function normalizeNewRelicAttributeKey(value) {
+    let normalized = "";
+    for (const character of value) {
+        normalized += /[A-Za-z0-9:._]/.test(character) ? character : "_";
+    }
+    return normalized;
+}
+function maximumAttributeValueBytes(sink) {
+    return sink === "dynatrace" ? MAXIMUM_DYNATRACE_ATTRIBUTE_VALUE_BYTES : MAXIMUM_ATTRIBUTE_VALUE_BYTES;
+}
+function isCloudWatchDimensionName(value) {
+    return !value.startsWith(":") && isPrintableASCII(value) && value.trim().length > 0;
+}
+function isCloudWatchDimensionValue(value) {
+    return isPrintableASCII(value) && value.trim().length > 0;
+}
+function isPrintableASCII(value) {
+    for (const character of value) {
+        const code = character.charCodeAt(0);
+        if (code < 0x20 || code > 0x7e)
+            return false;
+    }
+    return true;
+}
+function protocolError(sink, field) {
+    const displayName = sink === "newrelic" ? "New Relic" : sink === "cloudwatch" ? "CloudWatch" : sink;
+    return new Error(`${displayName} reporting metric has an invalid ${field}.`);
+}
+function compareOrdinal(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}

package/dist/cjs/iteration-observations.js

@@ -156,7 +156,7 @@ class ProcessIterationObservationBuffer {
 exports.ProcessIterationObservationBuffer = ProcessIterationObservationBuffer;
 const processIterationObservationBuffer = new ProcessIterationObservationBuffer();
 class SinkDispatcher {
-    constructor(target, depth, parallelism, retryCount, retryBackoffMs, logger, runId, resultOwnerId, onDropped) {
+    constructor(target, depth, parallelism, retryCount, retryBackoffMs, logger, runId, resultOwnerId, retryableErrorClassifier, onDropped) {
         this.target = target;
         this.depth = depth;
         this.parallelism = parallelism;
@@ -165,6 +165,7 @@ class SinkDispatcher {
         this.logger = logger;
         this.runId = runId;
         this.resultOwnerId = resultOwnerId;
+        this.retryableErrorClassifier = retryableErrorClassifier;
         this.onDropped = onDropped;
         this.queue = [];
         this.active = new Set();
@@ -277,12 +278,14 @@ class SinkDispatcher {
                 return "success";
             }
             catch (error) {
-                const exhausted = attempt >= maximumAttempts;
+                const retryable = this.isRetryableError(error);
+                const exhausted = attempt >= maximumAttempts || !retryable;
+                const reportedMaximumAttempts = retryable ? maximumAttempts : attempt;
                 const nextDelayMs = exhausted
                     ? 0
                     : (0, sink_retry_policy_js_1.sinkRetryDelayMs)(this.retryBackoffMs, attempt);
                 (0, iteration_observation_diagnostics_js_1.logIterationObservationFailure)(this.logger, exhausted ? "error" : "warn", {
-                    ...this.diagnosticContext(item, attempt, maximumAttempts),
+                    ...this.diagnosticContext(item, attempt, reportedMaximumAttempts),
                     nextDelayMs
                 }, error);
                 if (exhausted) {
@@ -296,6 +299,17 @@ class SinkDispatcher {
         }
         return "exhausted";
     }
+    isRetryableError(error) {
+        if (!this.retryableErrorClassifier) {
+            return true;
+        }
+        try {
+            return this.retryableErrorClassifier(error) !== false;
+        }
+        catch {
+            return true;
+        }
+    }
     diagnosticContext(item, attempt, maximumAttempts) {
         return {
             sinkName: this.target.name,
@@ -420,7 +434,7 @@ class IterationObservationReporter {
             this.recordWarning("sink_iteration_batches_unsupported", sink.name, "", -1, 1n, "The reporting sink does not support raw iteration batches.");
             return false;
         })
-            .map((target) => new SinkDispatcher(target, this.settings.sinkQueueDepth, this.settings.sinkParallelism, (0, sink_retry_policy_js_1.normalizeSinkRetryCount)(options.sinkRetryCount), (0, sink_retry_policy_js_1.normalizeSinkRetryBackoffMs)(options.sinkRetryBackoffMs), options.logger, options.runId, options.resultOwnerId, (code, sinkName, observations) => this.recordSinkDrop(code, sinkName, observations)));
+            .map((target) => new SinkDispatcher(target, this.settings.sinkQueueDepth, this.settings.sinkParallelism, (0, sink_retry_policy_js_1.normalizeSinkRetryCount)(options.sinkRetryCount), (0, sink_retry_policy_js_1.normalizeSinkRetryBackoffMs)(options.sinkRetryBackoffMs), options.logger, options.runId, options.resultOwnerId, target.retryableErrorClassifier, (code, sinkName, observations) => this.recordSinkDrop(code, sinkName, observations)));
         if (this.dispatchers.length > 0) {
             this.buffer.register(this.streamKey, this.settings.maxBufferBytes);
         }
@@ -498,7 +512,7 @@ class IterationObservationReporter {
                 && dispatcher.droppedCount === 0n
                 && dispatcher.deliveredCount === this.captured;
             const completion = this.createCompletion(dispatcher, sinkReportingComplete);
-            const outcome = await this.completeWithRetries(complete, completion, deadline, dispatcher.target.name);
+            const outcome = await this.completeWithRetries(dispatcher, complete, completion, deadline, dispatcher.target.name);
             if (outcome === "success") {
                 return true;
             }
@@ -534,7 +548,7 @@ class IterationObservationReporter {
         };
         return { ...this.finalResult };
     }
-    async completeWithRetries(complete, completion, deadline, sinkName) {
+    async completeWithRetries(dispatcher, complete, completion, deadline, sinkName) {
         const retryCount = (0, sink_retry_policy_js_1.normalizeSinkRetryCount)(this.options.sinkRetryCount);
         const backoffMs = (0, sink_retry_policy_js_1.normalizeSinkRetryBackoffMs)(this.options.sinkRetryBackoffMs);
         const maximumAttempts = retryCount + 1;
@@ -573,7 +587,9 @@ class IterationObservationReporter {
             if (outcome.kind === "timeout") {
                 return "timeout";
             }
-            const exhausted = attempt >= maximumAttempts;
+            const retryable = dispatcher.isRetryableError(outcome.error);
+            const exhausted = attempt >= maximumAttempts || !retryable;
+            const reportedMaximumAttempts = retryable ? maximumAttempts : attempt;
             const nextDelayMs = exhausted ? 0 : (0, sink_retry_policy_js_1.sinkRetryDelayMs)(backoffMs, attempt);
             (0, iteration_observation_diagnostics_js_1.logIterationObservationFailure)(this.options.logger, exhausted ? "error" : "warn", {
                 sinkName,
@@ -582,7 +598,7 @@ class IterationObservationReporter {
                 resultOwnerId: this.options.resultOwnerId,
                 observationCount: 0,
                 attempt,
-                maximumAttempts,
+                maximumAttempts: reportedMaximumAttempts,
                 nextDelayMs
             }, outcome.error);
             if (exhausted) {