@loadstrike/loadstrike-sdk 1.0.31001 → 1.0.32601

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

@@ -0,0 +1,31 @@
+import protobuf from "protobufjs";
+import { prepareProtocolMetricPoints } from "./vendor-metric-payloads.js";
+const PrometheusLabel = new protobuf.Type("Label")
+    .add(new protobuf.Field("name", 1, "string"))
+    .add(new protobuf.Field("value", 2, "string"));
+const PrometheusSample = new protobuf.Type("Sample")
+    .add(new protobuf.Field("value", 1, "double"))
+    .add(new protobuf.Field("timestamp", 2, "int64"));
+const PrometheusTimeSeries = new protobuf.Type("TimeSeries")
+    .add(new protobuf.Field("labels", 1, "Label", "repeated"))
+    .add(new protobuf.Field("samples", 2, "Sample", "repeated"))
+    .add(PrometheusLabel)
+    .add(PrometheusSample);
+const PrometheusWriteRequest = new protobuf.Type("WriteRequest")
+    .add(new protobuf.Field("timeseries", 1, "TimeSeries", "repeated"))
+    .add(PrometheusTimeSeries);
+export function encodePrometheusRemoteWrite(points, staticLabels = {}) {
+    const prepared = 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/esm/internal/reporting-sink-http-error.js

@@ -0,0 +1,13 @@
+export 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;
+    }
+}

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

@@ -0,0 +1,382 @@
+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"]);
+export 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())
+            };
+        })
+    };
+}
+export function encodeDynatraceMetrics(points, staticDimensions = {}) {
+    const prepared = prepareProtocolMetricPoints("dynatrace", points, staticDimensions);
+    return encodeDynatracePreparedMetrics(prepared);
+}
+export 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);
+}
+export function encodeNewRelicMetricBatch(points, staticAttributes = {}) {
+    const prepared = prepareProtocolMetricPoints("newrelic", points, staticAttributes);
+    return encodeNewRelicPreparedMetrics(prepared);
+}
+export function encodeNewRelicMetricBatches(points, staticAttributes = {}, maximumBodyBytesExclusive = 1000000) {
+    const prepared = prepareProtocolMetricPoints("newrelic", points, staticAttributes);
+    return encodeTextBatches("newrelic", "application/json", prepared.map((point) => newRelicMetricJson(point)), '[{"metrics":[', "]}]", ",", maximumBodyBytesExclusive);
+}
+export 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/esm/iteration-observations.js

@@ -144,7 +144,7 @@ export class 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;
@@ -153,6 +153,7 @@ class SinkDispatcher {
         this.logger = logger;
         this.runId = runId;
         this.resultOwnerId = resultOwnerId;
+        this.retryableErrorClassifier = retryableErrorClassifier;
         this.onDropped = onDropped;
         this.queue = [];
         this.active = new Set();
@@ -265,12 +266,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
                     : sinkRetryDelayMs(this.retryBackoffMs, attempt);
                 logIterationObservationFailure(this.logger, exhausted ? "error" : "warn", {
-                    ...this.diagnosticContext(item, attempt, maximumAttempts),
+                    ...this.diagnosticContext(item, attempt, reportedMaximumAttempts),
                     nextDelayMs
                 }, error);
                 if (exhausted) {
@@ -284,6 +287,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,
@@ -408,7 +422,7 @@ export 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, normalizeSinkRetryCount(options.sinkRetryCount), 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, normalizeSinkRetryCount(options.sinkRetryCount), 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);
         }
@@ -486,7 +500,7 @@ export 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;
             }
@@ -522,7 +536,7 @@ export class IterationObservationReporter {
         };
         return { ...this.finalResult };
     }
-    async completeWithRetries(complete, completion, deadline, sinkName) {
+    async completeWithRetries(dispatcher, complete, completion, deadline, sinkName) {
         const retryCount = normalizeSinkRetryCount(this.options.sinkRetryCount);
         const backoffMs = normalizeSinkRetryBackoffMs(this.options.sinkRetryBackoffMs);
         const maximumAttempts = retryCount + 1;
@@ -561,7 +575,9 @@ export 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 : sinkRetryDelayMs(backoffMs, attempt);
             logIterationObservationFailure(this.options.logger, exhausted ? "error" : "warn", {
                 sinkName,
@@ -570,7 +586,7 @@ export class IterationObservationReporter {
                 resultOwnerId: this.options.resultOwnerId,
                 observationCount: 0,
                 attempt,
-                maximumAttempts,
+                maximumAttempts: reportedMaximumAttempts,
                 nextDelayMs
             }, outcome.error);
             if (exhausted) {

package/dist/esm/local-report-input.js

@@ -0,0 +1,17 @@
+export function emptyLocalReportInput() {
+    return {
+        history: {
+            status: "available",
+            points: []
+        }
+    };
+}
+export function distributedLocalReportInput() {
+    return {
+        history: {
+            status: "unavailable",
+            reasonCategory: "distributed_temporal_aggregation_unavailable",
+            points: []
+        }
+    };
+}