@loadstrike/loadstrike-sdk 0.1.0

package/dist/esm/sinks.js

@@ -0,0 +1,2657 @@
+import { LoadStrikePluginData as LoadStrikePluginDataModel, LoadStrikePluginDataTable as LoadStrikePluginDataTableModel } from "./runtime.js";
+import { Pool } from "pg";
+const DEFAULT_INFLUX_CONFIGURATION_SECTION_PATH = "LoadStrike:ReportingSinks:InfluxDb";
+const DEFAULT_GRAFANA_LOKI_CONFIGURATION_SECTION_PATH = "LoadStrike:ReportingSinks:GrafanaLoki";
+const DEFAULT_TIMESCALEDB_CONFIGURATION_SECTION_PATH = "LoadStrike:ReportingSinks:TimescaleDb";
+const DEFAULT_DATADOG_CONFIGURATION_SECTION_PATH = "LoadStrike:ReportingSinks:Datadog";
+const DEFAULT_SPLUNK_CONFIGURATION_SECTION_PATH = "LoadStrike:ReportingSinks:Splunk";
+const DEFAULT_OTEL_COLLECTOR_CONFIGURATION_SECTION_PATH = "LoadStrike:ReportingSinks:OtelCollector";
+const IDENTIFIER_REGEX = /^[A-Za-z_][A-Za-z0-9_]*$/;
+export class InfluxDbReportingSinkOptions {
+    constructor(initial = {}) {
+        this.ConfigurationSectionPath = DEFAULT_INFLUX_CONFIGURATION_SECTION_PATH;
+        this.BaseUrl = "";
+        this.WriteEndpointPath = "/api/v2/write";
+        this.Organization = "";
+        this.Bucket = "";
+        this.Token = "";
+        this.MeasurementName = "loadstrike";
+        this.MetricsMeasurementName = "loadstrike_metrics";
+        this.TimeoutSeconds = 30;
+        this.StaticTags = {};
+        const source = asRecord(initial);
+        this.ConfigurationSectionPath =
+            optionString(source, "configurationSectionPath", "ConfigurationSectionPath").trim()
+                || DEFAULT_INFLUX_CONFIGURATION_SECTION_PATH;
+        this.BaseUrl = optionString(source, "baseUrl", "BaseUrl").trim() || "";
+        this.WriteEndpointPath = optionString(source, "writeEndpointPath", "WriteEndpointPath").trim() || "/api/v2/write";
+        this.Organization = optionString(source, "organization", "Organization").trim() || "";
+        this.Bucket = optionString(source, "bucket", "Bucket").trim() || "";
+        this.Token = optionString(source, "token", "Token").trim() || "";
+        this.MeasurementName = optionString(source, "measurementName", "MeasurementName").trim() || "loadstrike";
+        this.MetricsMeasurementName = optionString(source, "metricsMeasurementName", "MetricsMeasurementName").trim() || "loadstrike_metrics";
+        this.TimeoutSeconds = Number.isFinite(optionNumber(source, "timeoutSeconds", "TimeoutSeconds"))
+            ? Number(optionNumber(source, "timeoutSeconds", "TimeoutSeconds"))
+            : 30;
+        this.TimeoutMs = Number.isFinite(optionNumber(source, "timeoutMs", "TimeoutMs"))
+            ? Number(optionNumber(source, "timeoutMs", "TimeoutMs"))
+            : undefined;
+        this.StaticTags = normalizeStringMap(optionRecord(source, "staticTags", "StaticTags"));
+        this.FetchImpl = pickRecordValue(source, "fetchImpl", "FetchImpl");
+    }
+}
+export class GrafanaLokiReportingSinkOptions {
+    constructor(initial = {}) {
+        this.ConfigurationSectionPath = DEFAULT_GRAFANA_LOKI_CONFIGURATION_SECTION_PATH;
+        this.BaseUrl = "";
+        this.PushEndpointPath = "/loki/api/v1/push";
+        this.MetricsBaseUrl = "";
+        this.MetricsEndpointPath = "/v1/metrics";
+        this.BearerToken = "";
+        this.Username = "";
+        this.Password = "";
+        this.TenantId = "";
+        this.TimeoutSeconds = 30;
+        this.StaticLabels = {};
+        this.MetricsHeaders = {};
+        const source = asRecord(initial);
+        this.ConfigurationSectionPath =
+            optionString(source, "configurationSectionPath", "ConfigurationSectionPath").trim()
+                || DEFAULT_GRAFANA_LOKI_CONFIGURATION_SECTION_PATH;
+        this.BaseUrl = optionString(source, "baseUrl", "BaseUrl").trim() || "";
+        this.PushEndpointPath = optionString(source, "pushEndpointPath", "PushEndpointPath").trim() || "/loki/api/v1/push";
+        this.MetricsBaseUrl = optionString(source, "metricsBaseUrl", "MetricsBaseUrl").trim() || "";
+        this.MetricsEndpointPath = optionString(source, "metricsEndpointPath", "MetricsEndpointPath").trim() || "/v1/metrics";
+        this.BearerToken = optionString(source, "bearerToken", "BearerToken").trim() || "";
+        this.Username = optionString(source, "username", "Username").trim() || "";
+        this.Password = String(pickRecordValue(source, "password", "Password") ?? "");
+        this.TenantId = optionString(source, "tenantId", "TenantId").trim() || "";
+        this.TimeoutSeconds = Number.isFinite(optionNumber(source, "timeoutSeconds", "TimeoutSeconds"))
+            ? Number(optionNumber(source, "timeoutSeconds", "TimeoutSeconds"))
+            : 30;
+        this.TimeoutMs = Number.isFinite(optionNumber(source, "timeoutMs", "TimeoutMs"))
+            ? Number(optionNumber(source, "timeoutMs", "TimeoutMs"))
+            : undefined;
+        this.StaticLabels = normalizeStringMap(optionRecord(source, "staticLabels", "StaticLabels"));
+        this.MetricsHeaders = normalizeStringMap(optionRecord(source, "metricsHeaders", "MetricsHeaders"));
+        this.FetchImpl = pickRecordValue(source, "fetchImpl", "FetchImpl");
+    }
+}
+export class TimescaleDbReportingSinkOptions {
+    constructor(initial = {}) {
+        this.ConfigurationSectionPath = DEFAULT_TIMESCALEDB_CONFIGURATION_SECTION_PATH;
+        this.ConnectionString = "";
+        this.Schema = "public";
+        this.TableName = "loadstrike_reporting_events";
+        this.MetricsTableName = "loadstrike_reporting_metrics";
+        this.CreateSchemaIfMissing = true;
+        this.EnableHypertableIfAvailable = true;
+        this.StaticTags = {};
+        const source = asRecord(initial);
+        this.ConfigurationSectionPath =
+            optionString(source, "configurationSectionPath", "ConfigurationSectionPath").trim()
+                || DEFAULT_TIMESCALEDB_CONFIGURATION_SECTION_PATH;
+        this.ConnectionString = optionString(source, "connectionString", "ConnectionString").trim() || "";
+        this.Schema = optionString(source, "schema", "Schema").trim() || "public";
+        this.TableName = optionString(source, "tableName", "TableName").trim() || "loadstrike_reporting_events";
+        this.MetricsTableName = optionString(source, "metricsTableName", "MetricsTableName").trim() || "loadstrike_reporting_metrics";
+        this.CreateSchemaIfMissing = pickBooleanValue(source, true, "createSchemaIfMissing", "CreateSchemaIfMissing");
+        this.EnableHypertableIfAvailable = pickBooleanValue(source, true, "enableHypertableIfAvailable", "EnableHypertableIfAvailable");
+        this.StaticTags = normalizeStringMap(optionRecord(source, "staticTags", "StaticTags"));
+        this.Insert = pickRecordValue(source, "insert", "Insert");
+        this.InsertMetrics = pickRecordValue(source, "insertMetrics", "InsertMetrics");
+    }
+}
+export class DatadogReportingSinkOptions {
+    constructor(initial = {}) {
+        this.ConfigurationSectionPath = DEFAULT_DATADOG_CONFIGURATION_SECTION_PATH;
+        this.BaseUrl = "";
+        this.LogsEndpointPath = "/api/v2/logs";
+        this.MetricsEndpointPath = "/api/v2/series";
+        this.ApiKey = "";
+        this.ApplicationKey = "";
+        this.Source = "loadstrike";
+        this.Service = "loadstrike";
+        this.Host = "";
+        this.TimeoutSeconds = 30;
+        this.StaticTags = {};
+        this.StaticAttributes = {};
+        const source = asRecord(initial);
+        this.ConfigurationSectionPath =
+            optionString(source, "configurationSectionPath", "ConfigurationSectionPath").trim()
+                || DEFAULT_DATADOG_CONFIGURATION_SECTION_PATH;
+        this.BaseUrl = optionString(source, "baseUrl", "BaseUrl").trim() || "";
+        this.LogsEndpointPath = optionString(source, "logsEndpointPath", "LogsEndpointPath").trim() || "/api/v2/logs";
+        this.MetricsEndpointPath = optionString(source, "metricsEndpointPath", "MetricsEndpointPath").trim() || "/api/v2/series";
+        this.ApiKey = optionString(source, "apiKey", "ApiKey").trim() || "";
+        this.ApplicationKey = optionString(source, "applicationKey", "ApplicationKey").trim() || "";
+        this.Source = optionString(source, "source", "Source").trim() || "loadstrike";
+        this.Service = optionString(source, "service", "Service").trim() || "loadstrike";
+        this.Host = optionString(source, "host", "Host").trim() || "";
+        this.TimeoutSeconds = Number.isFinite(optionNumber(source, "timeoutSeconds", "TimeoutSeconds"))
+            ? Number(optionNumber(source, "timeoutSeconds", "TimeoutSeconds"))
+            : 30;
+        this.TimeoutMs = Number.isFinite(optionNumber(source, "timeoutMs", "TimeoutMs"))
+            ? Number(optionNumber(source, "timeoutMs", "TimeoutMs"))
+            : undefined;
+        this.StaticTags = normalizeStringMap(optionRecord(source, "staticTags", "StaticTags"));
+        this.StaticAttributes = normalizeStringMap(optionRecord(source, "staticAttributes", "StaticAttributes"));
+        this.FetchImpl = pickRecordValue(source, "fetchImpl", "FetchImpl");
+    }
+}
+export class SplunkReportingSinkOptions {
+    constructor(initial = {}) {
+        this.ConfigurationSectionPath = DEFAULT_SPLUNK_CONFIGURATION_SECTION_PATH;
+        this.BaseUrl = "";
+        this.EventEndpointPath = "/services/collector/event";
+        this.Token = "";
+        this.Source = "loadstrike";
+        this.Sourcetype = "_json";
+        this.Index = "";
+        this.Host = "";
+        this.TimeoutSeconds = 30;
+        this.StaticFields = {};
+        const source = asRecord(initial);
+        this.ConfigurationSectionPath =
+            optionString(source, "configurationSectionPath", "ConfigurationSectionPath").trim()
+                || DEFAULT_SPLUNK_CONFIGURATION_SECTION_PATH;
+        this.BaseUrl = optionString(source, "baseUrl", "BaseUrl").trim() || "";
+        this.EventEndpointPath = optionString(source, "eventEndpointPath", "EventEndpointPath").trim() || "/services/collector/event";
+        this.Token = optionString(source, "token", "Token").trim() || "";
+        this.Source = optionString(source, "source", "Source").trim() || "loadstrike";
+        this.Sourcetype = optionString(source, "sourcetype", "Sourcetype").trim() || "_json";
+        this.Index = optionString(source, "index", "Index").trim() || "";
+        this.Host = optionString(source, "host", "Host").trim() || "";
+        this.TimeoutSeconds = Number.isFinite(optionNumber(source, "timeoutSeconds", "TimeoutSeconds"))
+            ? Number(optionNumber(source, "timeoutSeconds", "TimeoutSeconds"))
+            : 30;
+        this.TimeoutMs = Number.isFinite(optionNumber(source, "timeoutMs", "TimeoutMs"))
+            ? Number(optionNumber(source, "timeoutMs", "TimeoutMs"))
+            : undefined;
+        this.StaticFields = normalizeStringMap(optionRecord(source, "staticFields", "StaticFields"));
+        this.FetchImpl = pickRecordValue(source, "fetchImpl", "FetchImpl");
+    }
+}
+export class OtelCollectorReportingSinkOptions {
+    constructor(initial = {}) {
+        this.ConfigurationSectionPath = DEFAULT_OTEL_COLLECTOR_CONFIGURATION_SECTION_PATH;
+        this.BaseUrl = "";
+        this.LogsEndpointPath = "/v1/logs";
+        this.MetricsEndpointPath = "/v1/metrics";
+        this.TimeoutSeconds = 30;
+        this.Headers = {};
+        this.StaticResourceAttributes = {};
+        const source = asRecord(initial);
+        this.ConfigurationSectionPath =
+            optionString(source, "configurationSectionPath", "ConfigurationSectionPath").trim()
+                || DEFAULT_OTEL_COLLECTOR_CONFIGURATION_SECTION_PATH;
+        this.BaseUrl = optionString(source, "baseUrl", "BaseUrl").trim() || "";
+        this.LogsEndpointPath = optionString(source, "logsEndpointPath", "LogsEndpointPath").trim() || "/v1/logs";
+        this.MetricsEndpointPath = optionString(source, "metricsEndpointPath", "MetricsEndpointPath").trim() || "/v1/metrics";
+        this.TimeoutSeconds = Number.isFinite(optionNumber(source, "timeoutSeconds", "TimeoutSeconds"))
+            ? Number(optionNumber(source, "timeoutSeconds", "TimeoutSeconds"))
+            : 30;
+        this.TimeoutMs = Number.isFinite(optionNumber(source, "timeoutMs", "TimeoutMs"))
+            ? Number(optionNumber(source, "timeoutMs", "TimeoutMs"))
+            : undefined;
+        this.Headers = normalizeStringMap(optionRecord(source, "headers", "Headers"));
+        this.StaticResourceAttributes = normalizeStringMap(optionRecord(source, "staticResourceAttributes", "StaticResourceAttributes"));
+        this.FetchImpl = pickRecordValue(source, "fetchImpl", "FetchImpl");
+    }
+}
+export class MemoryReportingSink {
+    constructor() {
+        this.sinkName = "memory";
+        this.SinkName = "memory";
+        this.initContexts = [];
+        this.realtimeSnapshots = [];
+        this.realtimeMetrics = [];
+        this.finalResults = [];
+        this.runResults = [];
+        this.sessions = [];
+        this.stopCount = 0;
+    }
+    init(context, infraConfig) {
+        this.initContexts.push({ context: cloneBaseContext(context), infraConfig: deepCloneRecord(infraConfig) });
+    }
+    Init(context, infraConfig) {
+        this.init(context, infraConfig);
+    }
+    start(session) {
+        this.sessions.push(cloneSessionStartInfo(session));
+    }
+    Start(session) {
+        this.start(session);
+    }
+    saveRealtimeStats(scenarioStats) {
+        this.realtimeSnapshots.push(scenarioStats.map((value) => cloneScenarioStats(value)));
+    }
+    SaveRealtimeStats(scenarioStats) {
+        this.saveRealtimeStats(scenarioStats);
+    }
+    saveRealtimeMetrics(metrics) {
+        this.realtimeMetrics.push(cloneMetricStats(metrics));
+    }
+    SaveRealtimeMetrics(metrics) {
+        this.saveRealtimeMetrics(metrics);
+    }
+    saveFinalStats(result) {
+        this.finalResults.push(cloneNodeStats(result));
+    }
+    SaveFinalStats(result) {
+        this.saveFinalStats(result);
+    }
+    saveRunResult(result) {
+        this.runResults.push(deepCloneRecord(result));
+    }
+    SaveRunResult(result) {
+        this.saveRunResult(result);
+    }
+    stop() {
+        this.stopCount += 1;
+    }
+    Stop() {
+        this.stop();
+    }
+}
+export class ConsoleReportingSink {
+    constructor(writeLine) {
+        this.sinkName = "console";
+        this.SinkName = "console";
+        this.writeLine = writeLine ?? ((line) => { console.log(line); });
+    }
+    init() { }
+    Init() {
+        this.init();
+    }
+    start() { }
+    Start() {
+        this.start();
+    }
+    saveRealtimeStats(scenarioStats) {
+        const requestCount = scenarioStats.reduce((sum, value) => sum + value.allRequestCount, 0);
+        const okCount = scenarioStats.reduce((sum, value) => sum + value.allOkCount, 0);
+        const failCount = scenarioStats.reduce((sum, value) => sum + value.allFailCount, 0);
+        this.writeLine(`realtime requests=${requestCount} ok=${okCount} fail=${failCount}`);
+    }
+    SaveRealtimeStats(scenarioStats) {
+        this.saveRealtimeStats(scenarioStats);
+    }
+    saveRealtimeMetrics(metrics) {
+        this.writeLine(`metrics counters=${metrics.counters.length} gauges=${metrics.gauges.length}`);
+    }
+    SaveRealtimeMetrics(metrics) {
+        this.saveRealtimeMetrics(metrics);
+    }
+    saveFinalStats(result) {
+        this.writeLine(`final requests=${result.allRequestCount} ok=${result.allOkCount} fail=${result.allFailCount} failedThresholds=${result.failedThresholds}`);
+    }
+    SaveFinalStats(result) {
+        this.saveFinalStats(result);
+    }
+    saveRunResult(_result) { }
+    SaveRunResult(result) {
+        this.saveRunResult(result);
+    }
+    stop() { }
+    Stop() {
+        this.stop();
+    }
+}
+export class CompositeReportingSink {
+    constructor(...sinks) {
+        this.sinkName = "composite";
+        this.SinkName = "composite";
+        for (let index = 0; index < sinks.length; index += 1) {
+            const sink = sinks[index];
+            if (sink == null) {
+                throw new Error("Composite reporting sink cannot contain null sink values.");
+            }
+            const configuredName = String(sink.sinkName ?? sink.SinkName ?? "").trim();
+            if (!configuredName) {
+                throw new Error(`Composite reporting sink entries must provide sinkName or SinkName. Index=${index}.`);
+            }
+        }
+        this.sinks = sinks;
+    }
+    async init(context, infraConfig) {
+        for (const sink of this.sinks) {
+            const init = sink.init ?? sink.Init;
+            if (init) {
+                await init.call(sink, context, infraConfig);
+            }
+        }
+    }
+    async Init(context, infraConfig) {
+        await this.init(context, infraConfig);
+    }
+    async start(session) {
+        for (const sink of this.sinks) {
+            const start = sink.start ?? sink.Start;
+            if (start) {
+                await start.call(sink, session);
+            }
+        }
+    }
+    async Start(session) {
+        await this.start(session);
+    }
+    async saveRealtimeStats(scenarioStats) {
+        for (const sink of this.sinks) {
+            const saveRealtimeStats = sink.saveRealtimeStats ?? sink.SaveRealtimeStats;
+            if (saveRealtimeStats) {
+                await saveRealtimeStats.call(sink, scenarioStats);
+            }
+        }
+    }
+    async SaveRealtimeStats(scenarioStats) {
+        await this.saveRealtimeStats(scenarioStats);
+    }
+    async saveRealtimeMetrics(metrics) {
+        for (const sink of this.sinks) {
+            const saveRealtimeMetrics = sink.saveRealtimeMetrics ?? sink.SaveRealtimeMetrics;
+            if (saveRealtimeMetrics) {
+                await saveRealtimeMetrics.call(sink, metrics);
+            }
+        }
+    }
+    async SaveRealtimeMetrics(metrics) {
+        await this.saveRealtimeMetrics(metrics);
+    }
+    async saveFinalStats(result) {
+        for (const sink of this.sinks) {
+            const saveFinalStats = sink.saveFinalStats ?? sink.SaveFinalStats;
+            if (saveFinalStats) {
+                await saveFinalStats.call(sink, result);
+            }
+        }
+    }
+    async SaveFinalStats(result) {
+        await this.saveFinalStats(result);
+    }
+    async saveRunResult(result) {
+        for (const sink of this.sinks) {
+            const saveRunResult = sink.saveRunResult ?? sink.SaveRunResult;
+            if (saveRunResult) {
+                await saveRunResult.call(sink, result);
+            }
+        }
+    }
+    async SaveRunResult(result) {
+        await this.saveRunResult(result);
+    }
+    async stop() {
+        for (const sink of this.sinks) {
+            const stop = sink.stop ?? sink.Stop;
+            if (stop) {
+                await stop.call(sink);
+            }
+        }
+    }
+    async Stop() {
+        await this.stop();
+    }
+}
+export class InfluxDbReportingSink {
+    constructor(options = {}) {
+        this.sinkName = "influxdb";
+        this.SinkName = "influxdb";
+        this.licenseFeature = "extensions.reporting_sinks.influxdb";
+        this.LicenseFeature = "extensions.reporting_sinks.influxdb";
+        this.baseContext = null;
+        this.session = null;
+        const source = asRecord(options);
+        this.options = {
+            configurationSectionPath: optionString(source, "configurationSectionPath", "ConfigurationSectionPath").trim() || DEFAULT_INFLUX_CONFIGURATION_SECTION_PATH,
+            baseUrl: optionString(source, "baseUrl", "BaseUrl").trim() || "",
+            writeEndpointPath: optionString(source, "writeEndpointPath", "WriteEndpointPath").trim() || "/api/v2/write",
+            organization: optionString(source, "organization", "Organization").trim() || "",
+            bucket: optionString(source, "bucket", "Bucket").trim() || "",
+            token: optionString(source, "token", "Token").trim() || "",
+            measurementName: optionString(source, "measurementName", "MeasurementName").trim() || "loadstrike",
+            metricsMeasurementName: optionString(source, "metricsMeasurementName", "MetricsMeasurementName").trim() || "loadstrike_metrics",
+            timeoutSeconds: Number.isFinite(optionNumber(source, "timeoutSeconds", "TimeoutSeconds"))
+                ? Number(optionNumber(source, "timeoutSeconds", "TimeoutSeconds"))
+                : 30,
+            timeoutMs: Number.isFinite(optionNumber(source, "timeoutMs", "TimeoutMs"))
+                ? Number(optionNumber(source, "timeoutMs", "TimeoutMs"))
+                : undefined,
+            staticTags: normalizeStringMap(optionRecord(source, "staticTags", "StaticTags"))
+        };
+        this.fetchImpl = pickRecordValue(source, "fetchImpl", "FetchImpl") ?? fetch;
+    }
+    init(context, infraConfig) {
+        this.baseContext = cloneBaseContext(context);
+        mergeInfluxOptions(this.options, readInfluxOptionsFromConfig(infraConfig, this.options.configurationSectionPath));
+        if (!this.options.baseUrl.trim()) {
+            throw new Error("InfluxDbReportingSink requires BaseUrl.");
+        }
+        if (!this.options.organization.trim()) {
+            throw new Error("InfluxDbReportingSink requires Organization.");
+        }
+        if (!this.options.bucket.trim()) {
+            throw new Error("InfluxDbReportingSink requires Bucket.");
+        }
+    }
+    Init(context, infraConfig) {
+        this.init(context, infraConfig);
+    }
+    start(session) {
+        this.session = sinkSessionMetadataFromContext(this.getBaseContext(), session);
+    }
+    Start(session) {
+        this.start(session);
+    }
+    async saveRealtimeStats(scenarioStats) {
+        await this.persistEvents(createRealtimeStatsEvents(this.getSession(), scenarioStats));
+    }
+    async SaveRealtimeStats(scenarioStats) {
+        await this.saveRealtimeStats(scenarioStats);
+    }
+    async saveRealtimeMetrics(metrics) {
+        await this.persistEvents(createRealtimeMetricEvents(this.getSession(), metrics));
+    }
+    async SaveRealtimeMetrics(metrics) {
+        await this.saveRealtimeMetrics(metrics);
+    }
+    async saveFinalStats(result) {
+        await this.persistEvents(createFinalStatsEvents(this.getSession(), result));
+    }
+    async SaveFinalStats(result) {
+        await this.saveFinalStats(result);
+    }
+    async saveRunResult(result) {
+        await this.persistEvents(createRunResultEvents(this.getSession(), result));
+    }
+    async SaveRunResult(result) {
+        await this.saveRunResult(result);
+    }
+    stop() {
+        this.session = null;
+    }
+    Stop() {
+        this.stop();
+    }
+    Dispose() {
+        this.baseContext = null;
+        this.stop();
+    }
+    getBaseContext() {
+        if (!this.baseContext) {
+            throw new Error(`${this.sinkName} has not been initialized.`);
+        }
+        return this.baseContext;
+    }
+    getSession() {
+        if (!this.session) {
+            throw new Error(`${this.sinkName} has not been started.`);
+        }
+        return this.session;
+    }
+    async persistEvents(events) {
+        if (!events.length) {
+            return;
+        }
+        const payload = [
+            buildInfluxLineProtocol(this.options.measurementName, this.options.staticTags, events.filter((event) => !isMetricEventType(event.eventType))),
+            buildInfluxLineProtocol(this.options.metricsMeasurementName, this.options.staticTags, events.filter((event) => isMetricEventType(event.eventType)))
+        ]
+            .filter((value) => value.trim().length > 0)
+            .join("\n");
+        if (!payload) {
+            return;
+        }
+        await postWithTimeout(this.fetchImpl, buildInfluxWriteUri(this.options), {
+            method: "POST",
+            headers: {
+                "Content-Type": "text/plain; charset=utf-8",
+                ...(this.options.token ? { Authorization: `Token ${this.options.token}` } : {})
+            },
+            body: `${payload}\n`
+        }, resolveTimeoutMs(this.options.timeoutSeconds, this.options.timeoutMs), "InfluxDbReportingSink");
+    }
+}
+export class GrafanaLokiReportingSink {
+    constructor(options = {}) {
+        this.sinkName = "grafana-loki";
+        this.SinkName = "grafana-loki";
+        this.licenseFeature = "extensions.reporting_sinks.grafana_loki";
+        this.LicenseFeature = "extensions.reporting_sinks.grafana_loki";
+        this.baseContext = null;
+        this.session = null;
+        const source = asRecord(options);
+        this.options = {
+            configurationSectionPath: optionString(source, "configurationSectionPath", "ConfigurationSectionPath").trim() || DEFAULT_GRAFANA_LOKI_CONFIGURATION_SECTION_PATH,
+            baseUrl: optionString(source, "baseUrl", "BaseUrl").trim() || "",
+            pushEndpointPath: optionString(source, "pushEndpointPath", "PushEndpointPath").trim() || "/loki/api/v1/push",
+            metricsBaseUrl: optionString(source, "metricsBaseUrl", "MetricsBaseUrl").trim() || "",
+            metricsEndpointPath: optionString(source, "metricsEndpointPath", "MetricsEndpointPath").trim() || "/v1/metrics",
+            bearerToken: optionString(source, "bearerToken", "BearerToken").trim() || "",
+            username: optionString(source, "username", "Username").trim() || "",
+            password: String(pickRecordValue(source, "password", "Password") ?? ""),
+            tenantId: optionString(source, "tenantId", "TenantId").trim() || "",
+            timeoutSeconds: Number.isFinite(optionNumber(source, "timeoutSeconds", "TimeoutSeconds"))
+                ? Number(optionNumber(source, "timeoutSeconds", "TimeoutSeconds"))
+                : 30,
+            timeoutMs: Number.isFinite(optionNumber(source, "timeoutMs", "TimeoutMs"))
+                ? Number(optionNumber(source, "timeoutMs", "TimeoutMs"))
+                : undefined,
+            staticLabels: normalizeStringMap(optionRecord(source, "staticLabels", "StaticLabels")),
+            metricsHeaders: normalizeStringMap(optionRecord(source, "metricsHeaders", "MetricsHeaders"))
+        };
+        this.fetchImpl = pickRecordValue(source, "fetchImpl", "FetchImpl") ?? fetch;
+    }
+    init(context, infraConfig) {
+        this.baseContext = cloneBaseContext(context);
+        mergeGrafanaLokiOptions(this.options, readGrafanaLokiOptionsFromConfig(infraConfig, this.options.configurationSectionPath));
+        if (!this.options.baseUrl.trim()) {
+            throw new Error("GrafanaLokiReportingSink requires BaseUrl.");
+        }
+    }
+    Init(context, infraConfig) {
+        this.init(context, infraConfig);
+    }
+    start(session) {
+        this.session = sinkSessionMetadataFromContext(this.getBaseContext(), session);
+    }
+    Start(session) {
+        this.start(session);
+    }
+    async saveRealtimeStats(scenarioStats) {
+        await this.persistEvents(createRealtimeStatsEvents(this.getSession(), scenarioStats));
+    }
+    async SaveRealtimeStats(scenarioStats) {
+        await this.saveRealtimeStats(scenarioStats);
+    }
+    async saveRealtimeMetrics(metrics) {
+        await this.persistEvents(createRealtimeMetricEvents(this.getSession(), metrics));
+    }
+    async SaveRealtimeMetrics(metrics) {
+        await this.saveRealtimeMetrics(metrics);
+    }
+    async saveFinalStats(result) {
+        await this.persistEvents(createFinalStatsEvents(this.getSession(), result));
+    }
+    async SaveFinalStats(result) {
+        await this.saveFinalStats(result);
+    }
+    async saveRunResult(result) {
+        await this.persistEvents(createRunResultEvents(this.getSession(), result));
+    }
+    async SaveRunResult(result) {
+        await this.saveRunResult(result);
+    }
+    stop() {
+        this.session = null;
+    }
+    Stop() {
+        this.stop();
+    }
+    Dispose() {
+        this.baseContext = null;
+        this.stop();
+    }
+    getBaseContext() {
+        if (!this.baseContext) {
+            throw new Error(`${this.sinkName} has not been initialized.`);
+        }
+        return this.baseContext;
+    }
+    getSession() {
+        if (!this.session) {
+            throw new Error(`${this.sinkName} has not been started.`);
+        }
+        return this.session;
+    }
+    async persistEvents(events) {
+        if (!events.length) {
+            return;
+        }
+        const streams = groupGrafanaLokiStreams(this.options.staticLabels, events);
+        if (!streams.length) {
+            return;
+        }
+        const headers = {
+            "Content-Type": "application/json"
+        };
+        if (this.options.bearerToken) {
+            headers.Authorization = `Bearer ${this.options.bearerToken}`;
+        }
+        else if (this.options.username) {
+            const raw = Buffer.from(`${this.options.username}:${this.options.password}`).toString("base64");
+            headers.Authorization = `Basic ${raw}`;
+        }
+        if (this.options.tenantId) {
+            headers["X-Scope-OrgID"] = this.options.tenantId;
+        }
+        await postWithTimeout(this.fetchImpl, `${trimTrailingSlashes(this.options.baseUrl)}${normalizePath(this.options.pushEndpointPath)}`, {
+            method: "POST",
+            headers,
+            body: JSON.stringify({ streams })
+        }, resolveTimeoutMs(this.options.timeoutSeconds, this.options.timeoutMs), "GrafanaLokiReportingSink");
+        const metricPoints = createReportingSinkMetricPoints(this.sinkName, events, this.options.staticLabels);
+        if (!metricPoints.length) {
+            return;
+        }
+        const grouped = new Map();
+        for (const point of metricPoints) {
+            const key = `${point.metricName}|${point.metricKind}|${point.unitOfMeasure ?? ""}`;
+            const bucket = grouped.get(key) ?? [];
+            bucket.push(point);
+            grouped.set(key, bucket);
+        }
+        const metricsPayload = {
+            resourceMetrics: [{
+                    resource: { attributes: buildOtelResourceAttributes(this.sinkName, this.options.staticLabels) },
+                    scopeMetrics: [{
+                            scope: { name: "loadstrike.reporting", version: "1.0.0" },
+                            metrics: Array.from(grouped.values()).map((points) => buildOtelMetric(points[0], points))
+                        }]
+                }]
+        };
+        await postWithTimeout(this.fetchImpl, `${trimTrailingSlashes(this.options.metricsBaseUrl.trim() || this.options.baseUrl)}${normalizePath(this.options.metricsEndpointPath)}`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                ...this.options.metricsHeaders
+            },
+            body: JSON.stringify(metricsPayload)
+        }, resolveTimeoutMs(this.options.timeoutSeconds, this.options.timeoutMs), "GrafanaLokiReportingSink metrics");
+    }
+}
+export class TimescaleDbReportingSink {
+    constructor(options = {}) {
+        this.sinkName = "timescaledb";
+        this.SinkName = "timescaledb";
+        this.licenseFeature = "extensions.reporting_sinks.timescaledb";
+        this.LicenseFeature = "extensions.reporting_sinks.timescaledb";
+        this.rows = [];
+        this.baseContext = null;
+        this.session = null;
+        this.pool = null;
+        const source = asRecord(options);
+        this.options = {
+            configurationSectionPath: optionString(source, "configurationSectionPath", "ConfigurationSectionPath").trim() || DEFAULT_TIMESCALEDB_CONFIGURATION_SECTION_PATH,
+            connectionString: optionString(source, "connectionString", "ConnectionString").trim() || "",
+            schema: optionString(source, "schema", "Schema").trim() || "public",
+            tableName: optionString(source, "tableName", "TableName").trim() || "loadstrike_reporting_events",
+            metricsTableName: optionString(source, "metricsTableName", "MetricsTableName").trim() || "loadstrike_reporting_metrics",
+            createSchemaIfMissing: pickBooleanValue(source, true, "createSchemaIfMissing", "CreateSchemaIfMissing"),
+            enableHypertableIfAvailable: pickBooleanValue(source, true, "enableHypertableIfAvailable", "EnableHypertableIfAvailable"),
+            staticTags: normalizeStringMap(optionRecord(source, "staticTags", "StaticTags")),
+            insert: pickRecordValue(source, "insert", "Insert"),
+            insertMetrics: pickRecordValue(source, "insertMetrics", "InsertMetrics")
+        };
+    }
+    async init(context, infraConfig) {
+        this.baseContext = cloneBaseContext(context);
+        mergeTimescaleDbOptions(this.options, readTimescaleDbOptionsFromConfig(infraConfig, this.options.configurationSectionPath));
+        if (!this.options.insert && !this.options.connectionString.trim()) {
+            throw new Error("TimescaleDbReportingSink requires ConnectionString.");
+        }
+        validateIdentifier(this.options.schema, "Schema");
+        validateIdentifier(this.options.tableName, "TableName");
+        validateIdentifier(this.options.metricsTableName, "MetricsTableName");
+        if (!this.options.insert) {
+            this.pool = new Pool({
+                connectionString: this.options.connectionString
+            });
+            await this.ensureStorage(context.logger);
+        }
+    }
+    async Init(context, infraConfig) {
+        await this.init(context, infraConfig);
+    }
+    start(session) {
+        this.session = sinkSessionMetadataFromContext(this.getBaseContext(), session);
+    }
+    Start(session) {
+        this.start(session);
+    }
+    async saveRealtimeStats(scenarioStats) {
+        await this.persistEvents(createRealtimeStatsEvents(this.getSession(), scenarioStats));
+    }
+    async SaveRealtimeStats(scenarioStats) {
+        await this.saveRealtimeStats(scenarioStats);
+    }
+    async saveRealtimeMetrics(metrics) {
+        await this.persistEvents(createRealtimeMetricEvents(this.getSession(), metrics));
+    }
+    async SaveRealtimeMetrics(metrics) {
+        await this.saveRealtimeMetrics(metrics);
+    }
+    async saveFinalStats(result) {
+        await this.persistEvents(createFinalStatsEvents(this.getSession(), result));
+    }
+    async SaveFinalStats(result) {
+        await this.saveFinalStats(result);
+    }
+    async saveRunResult(result) {
+        await this.persistEvents(createRunResultEvents(this.getSession(), result));
+    }
+    async SaveRunResult(result) {
+        await this.saveRunResult(result);
+    }
+    async stop() {
+        this.session = null;
+        if (this.pool) {
+            const pool = this.pool;
+            this.pool = null;
+            await pool.end();
+        }
+    }
+    async Stop() {
+        await this.stop();
+    }
+    async Dispose() {
+        this.baseContext = null;
+        await this.stop();
+    }
+    getBufferedRows() {
+        return this.rows.map((value) => deepCloneRecord(value));
+    }
+    getBaseContext() {
+        if (!this.baseContext) {
+            throw new Error(`${this.sinkName} has not been initialized.`);
+        }
+        return this.baseContext;
+    }
+    getSession() {
+        if (!this.session) {
+            throw new Error(`${this.sinkName} has not been started.`);
+        }
+        return this.session;
+    }
+    async persistEvents(events) {
+        if (!events.length) {
+            return;
+        }
+        const rows = events.map((event) => ({
+            occurred_utc: event.occurredUtc.toISOString(),
+            session_id: event.sessionId,
+            test_suite: event.testSuite || null,
+            test_name: event.testName || null,
+            cluster_id: event.clusterId || null,
+            node_type: event.nodeType,
+            machine_name: event.machineName,
+            scenario_name: event.scenarioName,
+            step_name: event.stepName,
+            event_type: event.eventType,
+            tags: mergeTimescaleTags(event.tags, this.options.staticTags),
+            fields: deepCloneRecord(event.fields)
+        }));
+        const metricRows = createReportingSinkMetricPoints(this.sinkName, events, this.options.staticTags).map((point) => ({
+            occurred_utc: point.occurredUtc.toISOString(),
+            metric_name: point.metricName,
+            metric_kind: point.metricKind,
+            value: point.value,
+            unit_of_measure: point.unitOfMeasure ?? null,
+            tags: deepCloneRecord(point.tags)
+        }));
+        if (this.options.insert) {
+            await this.options.insert(quoteIdentifier(this.options.schema, this.options.tableName), rows.map((value) => deepCloneRecord(value)));
+            if (metricRows.length && this.options.insertMetrics) {
+                await this.options.insertMetrics(quoteIdentifier(this.options.schema, this.options.metricsTableName), metricRows.map((value) => deepCloneRecord(value)));
+            }
+            return;
+        }
+        if (this.pool) {
+            const client = await this.pool.connect();
+            try {
+                await client.query("BEGIN");
+                for (const row of rows) {
+                    await client.query(`INSERT INTO ${quoteIdentifier(this.options.schema, this.options.tableName)}
+            (
+              occurred_utc,
+              session_id,
+              test_suite,
+              test_name,
+              cluster_id,
+              node_type,
+              machine_name,
+              scenario_name,
+              step_name,
+              event_type,
+              tags,
+              fields
+            )
+            VALUES
+            (
+              $1,
+              $2,
+              $3,
+              $4,
+              $5,
+              $6,
+              $7,
+              $8,
+              $9,
+              $10,
+              $11::jsonb,
+              $12::jsonb
+            );`, [
+                        row.occurred_utc,
+                        row.session_id,
+                        row.test_suite,
+                        row.test_name,
+                        row.cluster_id,
+                        row.node_type,
+                        row.machine_name,
+                        row.scenario_name,
+                        row.step_name,
+                        row.event_type,
+                        JSON.stringify(row.tags),
+                        JSON.stringify(row.fields)
+                    ]);
+                }
+                for (const row of metricRows) {
+                    await client.query(`INSERT INTO ${quoteIdentifier(this.options.schema, this.options.metricsTableName)}
+            (
+              occurred_utc,
+              metric_name,
+              metric_kind,
+              value,
+              unit_of_measure,
+              tags
+            )
+            VALUES
+            (
+              $1,
+              $2,
+              $3,
+              $4,
+              $5,
+              $6::jsonb
+            );`, [
+                        row.occurred_utc,
+                        row.metric_name,
+                        row.metric_kind,
+                        row.value,
+                        row.unit_of_measure,
+                        JSON.stringify(row.tags)
+                    ]);
+                }
+                await client.query("COMMIT");
+            }
+            catch (error) {
+                await client.query("ROLLBACK");
+                throw error;
+            }
+            finally {
+                client.release();
+            }
+            return;
+        }
+        this.rows.push(...rows.map((value) => deepCloneRecord(value)));
+        this.rows.push(...metricRows.map((value) => deepCloneRecord(value)));
+    }
+    async ensureStorage(logger) {
+        if (!this.pool) {
+            return;
+        }
+        const client = await this.pool.connect();
+        try {
+            if (this.options.createSchemaIfMissing) {
+                await client.query(`CREATE SCHEMA IF NOT EXISTS ${quoteIdentifierPart(this.options.schema)};`);
+            }
+            await client.query(`CREATE TABLE IF NOT EXISTS ${quoteIdentifier(this.options.schema, this.options.tableName)}
+        (
+          id BIGSERIAL PRIMARY KEY,
+          occurred_utc TIMESTAMPTZ NOT NULL,
+          session_id TEXT NOT NULL,
+          test_suite TEXT NULL,
+          test_name TEXT NULL,
+          cluster_id TEXT NULL,
+          node_type TEXT NOT NULL,
+          machine_name TEXT NOT NULL,
+          scenario_name TEXT NULL,
+          step_name TEXT NULL,
+          event_type TEXT NOT NULL,
+          tags JSONB NOT NULL,
+          fields JSONB NOT NULL
+        );`);
+            await client.query(`CREATE TABLE IF NOT EXISTS ${quoteIdentifier(this.options.schema, this.options.metricsTableName)}
+        (
+          id BIGSERIAL PRIMARY KEY,
+          occurred_utc TIMESTAMPTZ NOT NULL,
+          metric_name TEXT NOT NULL,
+          metric_kind TEXT NOT NULL,
+          value DOUBLE PRECISION NOT NULL,
+          unit_of_measure TEXT NULL,
+          tags JSONB NOT NULL
+        );`);
+            await client.query(`CREATE INDEX IF NOT EXISTS ix_${this.options.tableName}_occurred_utc ON ${quoteIdentifier(this.options.schema, this.options.tableName)} (occurred_utc DESC);`);
+            await client.query(`CREATE INDEX IF NOT EXISTS ix_${this.options.tableName}_session_id ON ${quoteIdentifier(this.options.schema, this.options.tableName)} (session_id);`);
+            await client.query(`CREATE INDEX IF NOT EXISTS ix_${this.options.metricsTableName}_occurred_utc ON ${quoteIdentifier(this.options.schema, this.options.metricsTableName)} (occurred_utc DESC);`);
+            await client.query(`CREATE INDEX IF NOT EXISTS ix_${this.options.metricsTableName}_metric_name ON ${quoteIdentifier(this.options.schema, this.options.metricsTableName)} (metric_name);`);
+            if (this.options.enableHypertableIfAvailable) {
+                try {
+                    await client.query("CREATE EXTENSION IF NOT EXISTS timescaledb;");
+                    await client.query(`SELECT create_hypertable('${this.options.schema}.${this.options.tableName}', 'occurred_utc', if_not_exists => TRUE);`);
+                    await client.query(`SELECT create_hypertable('${this.options.schema}.${this.options.metricsTableName}', 'occurred_utc', if_not_exists => TRUE);`);
+                }
+                catch (_error) {
+                    logger.warn("TimescaleDbReportingSink could not enable hypertable mode. Continuing with standard PostgreSQL table.");
+                }
+            }
+        }
+        finally {
+            client.release();
+        }
+    }
+}
+export class DatadogReportingSink {
+    constructor(options = {}) {
+        this.sinkName = "datadog";
+        this.SinkName = "datadog";
+        this.licenseFeature = "extensions.reporting_sinks.datadog";
+        this.LicenseFeature = "extensions.reporting_sinks.datadog";
+        this.baseContext = null;
+        this.session = null;
+        const source = asRecord(options);
+        this.options = {
+            configurationSectionPath: optionString(source, "configurationSectionPath", "ConfigurationSectionPath").trim() || DEFAULT_DATADOG_CONFIGURATION_SECTION_PATH,
+            baseUrl: optionString(source, "baseUrl", "BaseUrl").trim() || "",
+            logsEndpointPath: optionString(source, "logsEndpointPath", "LogsEndpointPath").trim() || "/api/v2/logs",
+            metricsEndpointPath: optionString(source, "metricsEndpointPath", "MetricsEndpointPath").trim() || "/api/v2/series",
+            apiKey: optionString(source, "apiKey", "ApiKey").trim() || "",
+            applicationKey: optionString(source, "applicationKey", "ApplicationKey").trim() || "",
+            source: optionString(source, "source", "Source").trim() || "loadstrike",
+            service: optionString(source, "service", "Service").trim() || "loadstrike",
+            host: optionString(source, "host", "Host").trim() || "",
+            timeoutSeconds: Number.isFinite(optionNumber(source, "timeoutSeconds", "TimeoutSeconds"))
+                ? Number(optionNumber(source, "timeoutSeconds", "TimeoutSeconds"))
+                : 30,
+            timeoutMs: Number.isFinite(optionNumber(source, "timeoutMs", "TimeoutMs"))
+                ? Number(optionNumber(source, "timeoutMs", "TimeoutMs"))
+                : undefined,
+            staticTags: normalizeStringMap(optionRecord(source, "staticTags", "StaticTags")),
+            staticAttributes: normalizeStringMap(optionRecord(source, "staticAttributes", "StaticAttributes"))
+        };
+        this.fetchImpl = pickRecordValue(source, "fetchImpl", "FetchImpl") ?? fetch;
+    }
+    init(context, infraConfig) {
+        this.baseContext = cloneBaseContext(context);
+        mergeDatadogOptions(this.options, readDatadogOptionsFromConfig(infraConfig, this.options.configurationSectionPath));
+        if (!this.options.baseUrl.trim()) {
+            throw new Error("DatadogReportingSink requires BaseUrl.");
+        }
+        if (!this.options.apiKey.trim()) {
+            throw new Error("DatadogReportingSink requires ApiKey.");
+        }
+    }
+    Init(context, infraConfig) {
+        this.init(context, infraConfig);
+    }
+    start(session) {
+        this.session = sinkSessionMetadataFromContext(this.getBaseContext(), session);
+    }
+    Start(session) {
+        this.start(session);
+    }
+    async saveRealtimeStats(scenarioStats) {
+        await this.persistEvents(createRealtimeStatsEvents(this.getSession(), scenarioStats));
+    }
+    async SaveRealtimeStats(scenarioStats) {
+        await this.saveRealtimeStats(scenarioStats);
+    }
+    async saveRealtimeMetrics(metrics) {
+        await this.persistEvents(createRealtimeMetricEvents(this.getSession(), metrics));
+    }
+    async SaveRealtimeMetrics(metrics) {
+        await this.saveRealtimeMetrics(metrics);
+    }
+    async saveFinalStats(result) {
+        await this.persistEvents(createFinalStatsEvents(this.getSession(), result));
+    }
+    async SaveFinalStats(result) {
+        await this.saveFinalStats(result);
+    }
+    async saveRunResult(result) {
+        await this.persistEvents(createRunResultEvents(this.getSession(), result));
+    }
+    async SaveRunResult(result) {
+        await this.saveRunResult(result);
+    }
+    stop() {
+        this.session = null;
+    }
+    Stop() {
+        this.stop();
+    }
+    Dispose() {
+        this.baseContext = null;
+        this.stop();
+    }
+    getBaseContext() {
+        if (!this.baseContext) {
+            throw new Error(`${this.sinkName} has not been initialized.`);
+        }
+        return this.baseContext;
+    }
+    getSession() {
+        if (!this.session) {
+            throw new Error(`${this.sinkName} has not been started.`);
+        }
+        return this.session;
+    }
+    async persistEvents(events) {
+        if (!events.length) {
+            return;
+        }
+        const headers = {
+            "Content-Type": "application/json",
+            "DD-API-KEY": this.options.apiKey
+        };
+        if (this.options.applicationKey) {
+            headers["DD-APPLICATION-KEY"] = this.options.applicationKey;
+        }
+        const logEntries = events.map((event) => buildDatadogLogEntry(this.options, event));
+        await postWithTimeout(this.fetchImpl, `${trimTrailingSlashes(this.options.baseUrl)}${normalizePath(this.options.logsEndpointPath)}`, {
+            method: "POST",
+            headers,
+            body: JSON.stringify(logEntries)
+        }, resolveTimeoutMs(this.options.timeoutSeconds, this.options.timeoutMs), "DatadogReportingSink logs");
+        const series = createReportingSinkMetricPoints(this.sinkName, events, this.options.staticTags).map((point) => ({
+            metric: point.metricName,
+            type: point.metricKind,
+            points: [[toUnixSeconds(point.occurredUtc), point.value]],
+            tags: Object.entries(point.tags)
+                .sort(([left], [right]) => left.localeCompare(right))
+                .map(([key, value]) => `${sanitizeDatadogTagComponent(key)}:${sanitizeDatadogTagComponent(value)}`)
+        }));
+        if (!series.length) {
+            return;
+        }
+        await postWithTimeout(this.fetchImpl, `${trimTrailingSlashes(this.options.baseUrl)}${normalizePath(this.options.metricsEndpointPath)}`, {
+            method: "POST",
+            headers,
+            body: JSON.stringify({ series })
+        }, resolveTimeoutMs(this.options.timeoutSeconds, this.options.timeoutMs), "DatadogReportingSink metrics");
+    }
+}
+export class SplunkReportingSink {
+    constructor(options = {}) {
+        this.sinkName = "splunk";
+        this.SinkName = "splunk";
+        this.licenseFeature = "extensions.reporting_sinks.splunk";
+        this.LicenseFeature = "extensions.reporting_sinks.splunk";
+        this.baseContext = null;
+        this.session = null;
+        const source = asRecord(options);
+        this.options = {
+            configurationSectionPath: optionString(source, "configurationSectionPath", "ConfigurationSectionPath").trim() || DEFAULT_SPLUNK_CONFIGURATION_SECTION_PATH,
+            baseUrl: optionString(source, "baseUrl", "BaseUrl").trim() || "",
+            eventEndpointPath: optionString(source, "eventEndpointPath", "EventEndpointPath").trim() || "/services/collector/event",
+            token: optionString(source, "token", "Token").trim() || "",
+            source: optionString(source, "source", "Source").trim() || "loadstrike",
+            sourcetype: optionString(source, "sourcetype", "Sourcetype").trim() || "_json",
+            index: optionString(source, "index", "Index").trim() || "",
+            host: optionString(source, "host", "Host").trim() || "",
+            timeoutSeconds: Number.isFinite(optionNumber(source, "timeoutSeconds", "TimeoutSeconds"))
+                ? Number(optionNumber(source, "timeoutSeconds", "TimeoutSeconds"))
+                : 30,
+            timeoutMs: Number.isFinite(optionNumber(source, "timeoutMs", "TimeoutMs"))
+                ? Number(optionNumber(source, "timeoutMs", "TimeoutMs"))
+                : undefined,
+            staticFields: normalizeStringMap(optionRecord(source, "staticFields", "StaticFields"))
+        };
+        this.fetchImpl = pickRecordValue(source, "fetchImpl", "FetchImpl") ?? fetch;
+    }
+    init(context, infraConfig) {
+        this.baseContext = cloneBaseContext(context);
+        mergeSplunkOptions(this.options, readSplunkOptionsFromConfig(infraConfig, this.options.configurationSectionPath));
+        if (!this.options.baseUrl.trim()) {
+            throw new Error("SplunkReportingSink requires BaseUrl.");
+        }
+        if (!this.options.token.trim()) {
+            throw new Error("SplunkReportingSink requires Token.");
+        }
+    }
+    Init(context, infraConfig) {
+        this.init(context, infraConfig);
+    }
+    start(session) {
+        this.session = sinkSessionMetadataFromContext(this.getBaseContext(), session);
+    }
+    Start(session) {
+        this.start(session);
+    }
+    async saveRealtimeStats(scenarioStats) {
+        await this.persistEvents(createRealtimeStatsEvents(this.getSession(), scenarioStats));
+    }
+    async SaveRealtimeStats(scenarioStats) {
+        await this.saveRealtimeStats(scenarioStats);
+    }
+    async saveRealtimeMetrics(metrics) {
+        await this.persistEvents(createRealtimeMetricEvents(this.getSession(), metrics));
+    }
+    async SaveRealtimeMetrics(metrics) {
+        await this.saveRealtimeMetrics(metrics);
+    }
+    async saveFinalStats(result) {
+        await this.persistEvents(createFinalStatsEvents(this.getSession(), result));
+    }
+    async SaveFinalStats(result) {
+        await this.saveFinalStats(result);
+    }
+    async saveRunResult(result) {
+        await this.persistEvents(createRunResultEvents(this.getSession(), result));
+    }
+    async SaveRunResult(result) {
+        await this.saveRunResult(result);
+    }
+    stop() {
+        this.session = null;
+    }
+    Stop() {
+        this.stop();
+    }
+    Dispose() {
+        this.baseContext = null;
+        this.stop();
+    }
+    getBaseContext() {
+        if (!this.baseContext) {
+            throw new Error(`${this.sinkName} has not been initialized.`);
+        }
+        return this.baseContext;
+    }
+    getSession() {
+        if (!this.session) {
+            throw new Error(`${this.sinkName} has not been started.`);
+        }
+        return this.session;
+    }
+    async persistEvents(events) {
+        if (!events.length) {
+            return;
+        }
+        const envelopes = [
+            ...events.map((event) => JSON.stringify(buildSplunkLogEnvelope(this.options, event))),
+            ...createReportingSinkMetricPoints(this.sinkName, events, {}).map((point) => JSON.stringify(buildSplunkMetricEnvelope(this.options, point)))
+        ];
+        if (!envelopes.length) {
+            return;
+        }
+        await postWithTimeout(this.fetchImpl, `${trimTrailingSlashes(this.options.baseUrl)}${normalizePath(this.options.eventEndpointPath)}`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Splunk ${this.options.token}`
+            },
+            body: envelopes.join("\n")
+        }, resolveTimeoutMs(this.options.timeoutSeconds, this.options.timeoutMs), "SplunkReportingSink");
+    }
+}
+export class OtelCollectorReportingSink {
+    constructor(options = {}) {
+        this.sinkName = "otel-collector";
+        this.SinkName = "otel-collector";
+        this.licenseFeature = "extensions.reporting_sinks.otel_collector";
+        this.LicenseFeature = "extensions.reporting_sinks.otel_collector";
+        this.baseContext = null;
+        this.session = null;
+        const source = asRecord(options);
+        this.options = {
+            configurationSectionPath: optionString(source, "configurationSectionPath", "ConfigurationSectionPath").trim() || DEFAULT_OTEL_COLLECTOR_CONFIGURATION_SECTION_PATH,
+            baseUrl: optionString(source, "baseUrl", "BaseUrl").trim() || "",
+            logsEndpointPath: optionString(source, "logsEndpointPath", "LogsEndpointPath").trim() || "/v1/logs",
+            metricsEndpointPath: optionString(source, "metricsEndpointPath", "MetricsEndpointPath").trim() || "/v1/metrics",
+            timeoutSeconds: Number.isFinite(optionNumber(source, "timeoutSeconds", "TimeoutSeconds"))
+                ? Number(optionNumber(source, "timeoutSeconds", "TimeoutSeconds"))
+                : 30,
+            timeoutMs: Number.isFinite(optionNumber(source, "timeoutMs", "TimeoutMs"))
+                ? Number(optionNumber(source, "timeoutMs", "TimeoutMs"))
+                : undefined,
+            headers: normalizeStringMap(optionRecord(source, "headers", "Headers")),
+            staticResourceAttributes: normalizeStringMap(optionRecord(source, "staticResourceAttributes", "StaticResourceAttributes"))
+        };
+        this.fetchImpl = pickRecordValue(source, "fetchImpl", "FetchImpl") ?? fetch;
+    }
+    init(context, infraConfig) {
+        this.baseContext = cloneBaseContext(context);
+        mergeOtelCollectorOptions(this.options, readOtelCollectorOptionsFromConfig(infraConfig, this.options.configurationSectionPath));
+        if (!this.options.baseUrl.trim()) {
+            throw new Error("OtelCollectorReportingSink requires BaseUrl.");
+        }
+    }
+    Init(context, infraConfig) {
+        this.init(context, infraConfig);
+    }
+    start(session) {
+        this.session = sinkSessionMetadataFromContext(this.getBaseContext(), session);
+    }
+    Start(session) {
+        this.start(session);
+    }
+    async saveRealtimeStats(scenarioStats) {
+        await this.persistEvents(createRealtimeStatsEvents(this.getSession(), scenarioStats));
+    }
+    async SaveRealtimeStats(scenarioStats) {
+        await this.saveRealtimeStats(scenarioStats);
+    }
+    async saveRealtimeMetrics(metrics) {
+        await this.persistEvents(createRealtimeMetricEvents(this.getSession(), metrics));
+    }
+    async SaveRealtimeMetrics(metrics) {
+        await this.saveRealtimeMetrics(metrics);
+    }
+    async saveFinalStats(result) {
+        await this.persistEvents(createFinalStatsEvents(this.getSession(), result));
+    }
+    async SaveFinalStats(result) {
+        await this.saveFinalStats(result);
+    }
+    async saveRunResult(result) {
+        await this.persistEvents(createRunResultEvents(this.getSession(), result));
+    }
+    async SaveRunResult(result) {
+        await this.saveRunResult(result);
+    }
+    stop() {
+        this.session = null;
+    }
+    Stop() {
+        this.stop();
+    }
+    Dispose() {
+        this.baseContext = null;
+        this.stop();
+    }
+    getBaseContext() {
+        if (!this.baseContext) {
+            throw new Error(`${this.sinkName} has not been initialized.`);
+        }
+        return this.baseContext;
+    }
+    getSession() {
+        if (!this.session) {
+            throw new Error(`${this.sinkName} has not been started.`);
+        }
+        return this.session;
+    }
+    async persistEvents(events) {
+        if (!events.length) {
+            return;
+        }
+        const headers = {
+            "Content-Type": "application/json",
+            ...this.options.headers
+        };
+        const resourceAttributes = buildOtelResourceAttributes(this.sinkName, this.options.staticResourceAttributes);
+        const logPayload = {
+            resourceLogs: [{
+                    resource: { attributes: resourceAttributes },
+                    scopeLogs: [{
+                            scope: { name: "loadstrike.reporting", version: "1.0.0" },
+                            logRecords: events.map((event) => buildOtelLogRecord(event))
+                        }]
+                }]
+        };
+        await postWithTimeout(this.fetchImpl, `${trimTrailingSlashes(this.options.baseUrl)}${normalizePath(this.options.logsEndpointPath)}`, {
+            method: "POST",
+            headers,
+            body: JSON.stringify(logPayload)
+        }, resolveTimeoutMs(this.options.timeoutSeconds, this.options.timeoutMs), "OtelCollectorReportingSink logs");
+        const metricPoints = createReportingSinkMetricPoints(this.sinkName, events, {});
+        if (!metricPoints.length) {
+            return;
+        }
+        const grouped = new Map();
+        for (const point of metricPoints) {
+            const key = `${point.metricName}|${point.metricKind}|${point.unitOfMeasure ?? ""}`;
+            const values = grouped.get(key) ?? [];
+            values.push(point);
+            grouped.set(key, values);
+        }
+        const metricPayload = {
+            resourceMetrics: [{
+                    resource: { attributes: resourceAttributes },
+                    scopeMetrics: [{
+                            scope: { name: "loadstrike.reporting", version: "1.0.0" },
+                            metrics: Array.from(grouped.values()).map((points) => buildOtelMetric(points[0], points))
+                        }]
+                }]
+        };
+        await postWithTimeout(this.fetchImpl, `${trimTrailingSlashes(this.options.baseUrl)}${normalizePath(this.options.metricsEndpointPath)}`, {
+            method: "POST",
+            headers,
+            body: JSON.stringify(metricPayload)
+        }, resolveTimeoutMs(this.options.timeoutSeconds, this.options.timeoutMs), "OtelCollectorReportingSink metrics");
+    }
+}
+function createRealtimeStatsEvents(session, scenarios) {
+    const occurredUtc = new Date();
+    const events = [];
+    for (const scenario of scenarios) {
+        events.push(createScenarioEvent(session, occurredUtc, "realtime", scenario));
+        events.push(...createStepEvents(session, occurredUtc, "realtime", scenario));
+        events.push(...createStatusCodeEvents(session, occurredUtc, "realtime", scenario.scenarioName, null, "ok", scenario.ok.statusCodes));
+        events.push(...createStatusCodeEvents(session, occurredUtc, "realtime", scenario.scenarioName, null, "fail", scenario.fail.statusCodes));
+    }
+    return events;
+}
+function createRealtimeMetricEvents(session, metrics) {
+    return createMetricEvents(session, metrics, "realtime");
+}
+function createFinalStatsEvents(session, stats) {
+    const occurredUtc = new Date();
+    const events = [createNodeSummaryEvent(session, occurredUtc, stats)];
+    for (const scenario of stats.scenarioStats) {
+        events.push(createScenarioEvent(session, occurredUtc, "final", scenario));
+        events.push(...createStepEvents(session, occurredUtc, "final", scenario));
+        events.push(...createStatusCodeEvents(session, occurredUtc, "final", scenario.scenarioName, null, "ok", scenario.ok.statusCodes));
+        events.push(...createStatusCodeEvents(session, occurredUtc, "final", scenario.scenarioName, null, "fail", scenario.fail.statusCodes));
+    }
+    events.push(...createMetricEvents(session, stats.metrics, "final", occurredUtc));
+    for (const threshold of stats.thresholds) {
+        events.push(createThresholdEvent(session, occurredUtc, threshold));
+    }
+    for (const plugin of stats.pluginsData) {
+        events.push(...createPluginEvents(session, occurredUtc, plugin));
+    }
+    return events;
+}
+function createRunResultEvents(session, result) {
+    const occurredUtc = new Date();
+    const events = [
+        createReportingEvent(session, occurredUtc, "run.result.final", null, null, {
+            phase: "final",
+            entity: "run-result"
+        }, {
+            started_utc: result.startedUtc,
+            completed_utc: result.completedUtc,
+            report_file_count: result.reportFiles.length,
+            disabled_sink_count: result.disabledSinks.length,
+            sink_error_count: result.sinkErrors.length
+        })
+    ];
+    for (const reportFile of result.reportFiles) {
+        events.push(createReportingEvent(session, occurredUtc, "run.report.final", null, null, {
+            phase: "final",
+            entity: "run-report"
+        }, {
+            path: reportFile
+        }));
+    }
+    for (const disabledSink of result.disabledSinks) {
+        events.push(createReportingEvent(session, occurredUtc, "run.disabled-sink.final", null, null, {
+            phase: "final",
+            entity: "disabled-sink",
+            sink_name: disabledSink
+        }, {
+            sink_name: disabledSink
+        }));
+    }
+    for (const sinkError of result.sinkErrors) {
+        events.push(createReportingEvent(session, occurredUtc, "run.sink-error.final", null, null, {
+            phase: "final",
+            entity: "sink-error",
+            sink_name: sinkError.sinkName,
+            sink_phase: sinkError.phase
+        }, {
+            sink_name: sinkError.sinkName,
+            phase: sinkError.phase,
+            message: sinkError.message,
+            attempts: sinkError.attempts
+        }));
+    }
+    return events;
+}
+function createNodeSummaryEvent(session, occurredUtc, stats) {
+    return createReportingEvent(session, occurredUtc, "test.final", null, null, {
+        phase: "final",
+        entity: "test"
+    }, {
+        all_request_count: stats.allRequestCount,
+        all_ok_count: stats.allOkCount,
+        all_fail_count: stats.allFailCount,
+        all_bytes: stats.allBytes,
+        duration_ms: stats.durationMs,
+        scenario_count: stats.scenarioStats.length,
+        threshold_count: stats.thresholds.length
+    });
+}
+function createScenarioEvent(session, occurredUtc, phase, scenario) {
+    const fields = {
+        all_request_count: scenario.allRequestCount,
+        all_ok_count: scenario.allOkCount,
+        all_fail_count: scenario.allFailCount,
+        all_bytes: scenario.allBytes,
+        duration_ms: scenario.durationMs,
+        sort_index: scenario.sortIndex,
+        operation: scenario.currentOperation,
+        load_simulation_name: scenario.loadSimulationStats.simulationName,
+        load_simulation_value: scenario.loadSimulationStats.value
+    };
+    addMeasurementFields(fields, "ok", scenario.ok);
+    addMeasurementFields(fields, "fail", scenario.fail);
+    return createReportingEvent(session, occurredUtc, `scenario.${phase}`, scenario.scenarioName, null, {
+        phase,
+        entity: "scenario"
+    }, fields);
+}
+function createStepEvents(session, occurredUtc, phase, scenario) {
+    const events = [];
+    for (const step of scenario.stepStats) {
+        const fields = {
+            sort_index: step.sortIndex
+        };
+        addMeasurementFields(fields, "ok", step.ok);
+        addMeasurementFields(fields, "fail", step.fail);
+        events.push(createReportingEvent(session, occurredUtc, `step.${phase}`, scenario.scenarioName, step.stepName, {
+            phase,
+            entity: "step"
+        }, fields));
+        events.push(...createStatusCodeEvents(session, occurredUtc, phase, scenario.scenarioName, step.stepName, "ok", step.ok.statusCodes));
+        events.push(...createStatusCodeEvents(session, occurredUtc, phase, scenario.scenarioName, step.stepName, "fail", step.fail.statusCodes));
+    }
+    return events;
+}
+function createStatusCodeEvents(session, occurredUtc, phase, scenarioName, stepName, resultKind, statusCodes) {
+    return statusCodes.map((statusCode) => createReportingEvent(session, occurredUtc, `status-code.${phase}`, scenarioName, stepName, {
+        phase,
+        entity: stepName ? "step-status-code" : "scenario-status-code",
+        result_kind: resultKind,
+        status_code: statusCode.statusCode
+    }, {
+        count: statusCode.count,
+        percent: statusCode.percent,
+        is_error: statusCode.isError,
+        message: statusCode.message
+    }));
+}
+function createMetricEvent(session, occurredUtc, eventType, scenarioName, tags, fields) {
+    return createReportingEvent(session, occurredUtc, eventType, scenarioName, null, tags, fields);
+}
+function createMetricEvents(session, metrics, phase, occurredUtc = new Date()) {
+    const events = [];
+    for (const counter of metrics?.counters ?? []) {
+        events.push(createMetricEvent(session, occurredUtc, phase === "final" ? "metric.counter.final" : "metric.counter", counter.scenarioName, {
+            phase,
+            metric_name: counter.metricName,
+            metric_type: "counter"
+        }, {
+            value: counter.value,
+            unit_of_measure: counter.unitOfMeasure,
+            duration_ms: metrics?.durationMs
+        }));
+    }
+    for (const gauge of metrics?.gauges ?? []) {
+        events.push(createMetricEvent(session, occurredUtc, phase === "final" ? "metric.gauge.final" : "metric.gauge", gauge.scenarioName, {
+            phase,
+            metric_name: gauge.metricName,
+            metric_type: "gauge"
+        }, {
+            value: gauge.value,
+            unit_of_measure: gauge.unitOfMeasure,
+            duration_ms: metrics?.durationMs
+        }));
+    }
+    return events;
+}
+function createThresholdEvent(session, occurredUtc, threshold) {
+    return createReportingEvent(session, occurredUtc, "threshold.final", threshold.scenarioName, cleanNullableText(threshold.stepName), {
+        phase: "final",
+        entity: "threshold"
+    }, {
+        check_expression: threshold.checkExpression,
+        is_failed: threshold.isFailed,
+        error_count: threshold.errorCount,
+        exception_message: threshold.exceptionMessage ?? null
+    });
+}
+function createPluginEvents(session, occurredUtc, plugin) {
+    const events = [];
+    for (const hint of plugin.hints) {
+        if (!String(hint ?? "").trim()) {
+            continue;
+        }
+        events.push(createReportingEvent(session, occurredUtc, "plugin.hint.final", null, null, {
+            phase: "final",
+            entity: "plugin-hint",
+            plugin_name: plugin.pluginName
+        }, {
+            hint
+        }));
+    }
+    for (const table of plugin.tables) {
+        for (let index = 0; index < table.rows.length; index += 1) {
+            const row = table.rows[index] ?? {};
+            const fields = {
+                row_index: index
+            };
+            for (const [key, value] of Object.entries(row)) {
+                fields[normalizePluginFieldName(key)] = normalizePluginFieldValue(value);
+            }
+            events.push(createReportingEvent(session, occurredUtc, "plugin.table.final", tryReadText(row, "Scenario"), tryReadText(row, "Step"), {
+                phase: "final",
+                entity: "plugin-table-row",
+                plugin_name: plugin.pluginName,
+                table_name: table.tableName
+            }, fields));
+        }
+    }
+    return events;
+}
+function createReportingEvent(session, occurredUtc, eventType, scenarioName, stepName, tags, fields) {
+    const mergedTags = {
+        event_type: eventType,
+        session_id: session.sessionId,
+        test_suite: session.testSuite.trim() ? session.testSuite : "default",
+        test_name: session.testName.trim() ? session.testName : "loadstrike",
+        cluster_id: session.clusterId.trim() ? session.clusterId : "default",
+        node_type: session.nodeType,
+        machine_name: session.machineName,
+        started_utc: session.startedUtc
+    };
+    if (scenarioName) {
+        mergedTags.scenario_name = scenarioName;
+    }
+    if (stepName) {
+        mergedTags.step_name = stepName;
+    }
+    for (const [key, value] of Object.entries(tags)) {
+        if (String(value ?? "").trim()) {
+            mergedTags[key] = String(value);
+        }
+    }
+    if (mergedTags.phase?.toLowerCase() === "final") {
+        mergedTags.completed_utc = occurredUtc.toISOString();
+    }
+    const eventFields = {
+        started_utc: session.startedUtc,
+        ...deepCloneRecord(fields)
+    };
+    if (mergedTags.phase?.toLowerCase() === "final") {
+        eventFields.completed_utc = occurredUtc.toISOString();
+    }
+    return {
+        eventType,
+        occurredUtc,
+        sessionId: session.sessionId,
+        testSuite: session.testSuite,
+        testName: session.testName,
+        clusterId: session.clusterId,
+        nodeType: session.nodeType,
+        machineName: session.machineName,
+        scenarioName,
+        stepName,
+        tags: mergedTags,
+        fields: eventFields
+    };
+}
+function addMeasurementFields(fields, prefix, measurement) {
+    fields[`${prefix}_request_count`] = measurement.request.count;
+    fields[`${prefix}_request_percent`] = measurement.request.percent;
+    fields[`${prefix}_request_rps`] = measurement.request.rps;
+    fields[`${prefix}_latency_min_ms`] = measurement.latency.minMs;
+    fields[`${prefix}_latency_mean_ms`] = measurement.latency.meanMs;
+    fields[`${prefix}_latency_max_ms`] = measurement.latency.maxMs;
+    fields[`${prefix}_latency_p50_ms`] = measurement.latency.percent50;
+    fields[`${prefix}_latency_p75_ms`] = measurement.latency.percent75;
+    fields[`${prefix}_latency_p95_ms`] = measurement.latency.percent95;
+    fields[`${prefix}_latency_p99_ms`] = measurement.latency.percent99;
+    fields[`${prefix}_latency_std_dev`] = measurement.latency.stdDev;
+    fields[`${prefix}_latency_le_800_count`] = measurement.latency.latencyCount.lessOrEq800;
+    fields[`${prefix}_latency_gt_800_lt_1200_count`] = measurement.latency.latencyCount.more800Less1200;
+    fields[`${prefix}_latency_ge_1200_count`] = measurement.latency.latencyCount.moreOrEq1200;
+    fields[`${prefix}_bytes_all`] = measurement.dataTransfer.allBytes;
+    fields[`${prefix}_bytes_min`] = measurement.dataTransfer.minBytes;
+    fields[`${prefix}_bytes_mean`] = measurement.dataTransfer.meanBytes;
+    fields[`${prefix}_bytes_max`] = measurement.dataTransfer.maxBytes;
+    fields[`${prefix}_bytes_p50`] = measurement.dataTransfer.percent50;
+    fields[`${prefix}_bytes_p75`] = measurement.dataTransfer.percent75;
+    fields[`${prefix}_bytes_p95`] = measurement.dataTransfer.percent95;
+    fields[`${prefix}_bytes_p99`] = measurement.dataTransfer.percent99;
+    fields[`${prefix}_bytes_std_dev`] = measurement.dataTransfer.stdDev;
+    fields[`${prefix}_status_code_count`] = measurement.statusCodes.length;
+}
+function buildInfluxWriteUri(options) {
+    const query = new URLSearchParams({
+        org: options.organization,
+        bucket: options.bucket,
+        precision: "ns"
+    });
+    return `${trimTrailingSlashes(options.baseUrl)}${normalizePath(options.writeEndpointPath)}?${query.toString()}`;
+}
+function buildInfluxLineProtocol(measurementName, staticTags, events) {
+    const lines = [];
+    for (const event of events) {
+        const fields = formatInfluxFields(event.fields);
+        if (!fields) {
+            continue;
+        }
+        const mergedTags = mergeInfluxTags(event.tags, staticTags);
+        const tagPart = Object.entries(mergedTags)
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([key, value]) => `${escapeInfluxToken(key)}=${escapeInfluxToken(value)}`)
+            .join(",");
+        lines.push(`${escapeInfluxToken(measurementName)}${tagPart ? `,${tagPart}` : ""} ${fields} ${toUnixNanoseconds(event.occurredUtc)}`);
+    }
+    return lines.join("\n");
+}
+function isMetricEventType(eventType) {
+    const normalized = String(eventType ?? "").toLowerCase();
+    return normalized.startsWith("metric.counter") || normalized.startsWith("metric.gauge");
+}
+function formatInfluxFields(fields) {
+    const parts = [];
+    for (const [key, value] of Object.entries(fields).sort(([left], [right]) => left.localeCompare(right))) {
+        const formatted = formatInfluxFieldValue(value);
+        if (formatted == null) {
+            continue;
+        }
+        parts.push(`${escapeInfluxToken(key)}=${formatted}`);
+    }
+    return parts.join(",");
+}
+function formatInfluxFieldValue(value) {
+    if (value == null) {
+        return null;
+    }
+    if (typeof value === "string") {
+        return `"${replaceLiteral(value, "\\", "\\\\").split("\"").join("\\\"")}"`;
+    }
+    if (typeof value === "boolean") {
+        return value ? "true" : "false";
+    }
+    if (typeof value === "number") {
+        if (!Number.isFinite(value)) {
+            return null;
+        }
+        return Number.isInteger(value) ? `${value}i` : String(value);
+    }
+    if (typeof value === "bigint") {
+        return `${value}i`;
+    }
+    return `"${replaceLiteral(String(value), "\\", "\\\\").split("\"").join("\\\"")}"`;
+}
+function mergeInfluxTags(eventTags, staticTags) {
+    const merged = {
+        source: "loadstrike",
+        sink: "influxdb"
+    };
+    for (const [key, value] of Object.entries(staticTags)) {
+        if (String(value ?? "").trim()) {
+            merged[key] = String(value);
+        }
+    }
+    for (const [key, value] of Object.entries(eventTags)) {
+        if (String(value ?? "").trim()) {
+            merged[key] = String(value);
+        }
+    }
+    return merged;
+}
+function groupGrafanaLokiStreams(staticLabels, events) {
+    const streams = new Map();
+    for (const event of events) {
+        const labels = buildGrafanaLokiLabels(staticLabels, event);
+        const key = Object.entries(labels)
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([labelKey, labelValue]) => `${labelKey}=${labelValue}`)
+            .join("|");
+        const entry = streams.get(key) ?? { stream: labels, values: [] };
+        entry.values.push([
+            toUnixNanoseconds(event.occurredUtc),
+            toReportingSinkEventJson(event)
+        ]);
+        streams.set(key, entry);
+    }
+    return Array.from(streams.values()).map((entry) => ({
+        stream: entry.stream,
+        values: entry.values.sort((left, right) => Number(left[0]) - Number(right[0]))
+    }));
+}
+function buildGrafanaLokiLabels(staticLabels, event) {
+    const labels = {
+        source: "loadstrike",
+        sink: "grafana_loki",
+        event_type: sanitizeGrafanaLabelValue(event.eventType),
+        test_suite: sanitizeGrafanaLabelValue(event.testSuite.trim() ? event.testSuite : "default"),
+        test_name: sanitizeGrafanaLabelValue(event.testName.trim() ? event.testName : "loadstrike")
+    };
+    for (const [key, value] of Object.entries(staticLabels)) {
+        if (String(value ?? "").trim()) {
+            labels[sanitizeGrafanaLabelKey(key)] = sanitizeGrafanaLabelValue(String(value));
+        }
+    }
+    return labels;
+}
+function mergeTimescaleTags(eventTags, staticTags) {
+    const merged = {
+        source: "loadstrike",
+        sink: "timescaledb"
+    };
+    for (const [key, value] of Object.entries(staticTags)) {
+        if (String(value ?? "").trim()) {
+            merged[key] = String(value);
+        }
+    }
+    for (const [key, value] of Object.entries(eventTags)) {
+        if (String(value ?? "").trim()) {
+            merged[key] = String(value);
+        }
+    }
+    return merged;
+}
+function toReportingSinkEventJson(event) {
+    return JSON.stringify({
+        EventType: event.eventType,
+        occurredUtc: event.occurredUtc.toISOString(),
+        SessionId: event.sessionId,
+        TestSuite: event.testSuite,
+        TestName: event.testName,
+        ClusterId: event.clusterId,
+        NodeType: event.nodeType,
+        MachineName: event.machineName,
+        ScenarioName: event.scenarioName,
+        StepName: event.stepName,
+        Tags: event.tags,
+        Fields: event.fields
+    });
+}
+function createReportingSinkMetricPoints(sinkName, events, staticTags) {
+    const points = [];
+    for (const event of events) {
+        const metricTags = buildMetricProjectionTags(sinkName, event, staticTags);
+        const normalizedEventType = event.eventType.toLowerCase();
+        const isCounterEvent = normalizedEventType.startsWith("metric.counter");
+        const isGaugeEvent = normalizedEventType.startsWith("metric.gauge");
+        const metricNameTag = event.tags.metric_name;
+        const unitOfMeasure = typeof event.fields.unit_of_measure === "string" && event.fields.unit_of_measure.trim()
+            ? event.fields.unit_of_measure.trim()
+            : undefined;
+        if ((isCounterEvent || isGaugeEvent) && isFiniteNumberLike(event.fields.value)) {
+            points.push({
+                metricName: buildCustomMetricName(metricNameTag),
+                metricKind: isCounterEvent ? "count" : "gauge",
+                occurredUtc: event.occurredUtc,
+                value: toNumericValue(event.fields.value),
+                unitOfMeasure,
+                tags: metricTags
+            });
+        }
+        for (const [fieldName, fieldValue] of Object.entries(event.fields)) {
+            if (fieldName.toLowerCase() === "unit_of_measure") {
+                continue;
+            }
+            if ((isCounterEvent || isGaugeEvent) && fieldName.toLowerCase() === "value") {
+                continue;
+            }
+            if (!isFiniteNumberLike(fieldValue)) {
+                continue;
+            }
+            points.push({
+                metricName: buildEventMetricName(event.eventType, fieldName),
+                metricKind: "gauge",
+                occurredUtc: event.occurredUtc,
+                value: toNumericValue(fieldValue),
+                unitOfMeasure: inferUnitOfMeasure(fieldName),
+                tags: metricTags
+            });
+        }
+    }
+    return points;
+}
+function buildMetricProjectionTags(sinkName, event, staticTags) {
+    const merged = {
+        source: "loadstrike",
+        sink: sinkName,
+        event_type: event.eventType,
+        session_id: event.sessionId,
+        test_suite: event.testSuite.trim() ? event.testSuite : "default",
+        test_name: event.testName.trim() ? event.testName : "loadstrike",
+        cluster_id: event.clusterId.trim() ? event.clusterId : "default",
+        node_type: event.nodeType.trim() ? event.nodeType : "SingleNode",
+        machine_name: event.machineName.trim() ? event.machineName : "local-machine"
+    };
+    if (event.scenarioName) {
+        merged.scenario_name = event.scenarioName;
+    }
+    if (event.stepName) {
+        merged.step_name = event.stepName;
+    }
+    for (const [key, value] of Object.entries(staticTags)) {
+        if (String(value ?? "").trim()) {
+            merged[key] = String(value);
+        }
+    }
+    for (const [key, value] of Object.entries(event.tags)) {
+        if (String(value ?? "").trim()) {
+            merged[key] = String(value);
+        }
+    }
+    return merged;
+}
+function buildCustomMetricName(metricName) {
+    const normalized = normalizeMetricPath(metricName);
+    return normalized ? `loadstrike.metric.${normalized}` : "loadstrike.metric.value";
+}
+function buildEventMetricName(eventType, fieldName) {
+    return `loadstrike.${normalizeMetricPath(eventType)}.${normalizeMetricPath(fieldName)}`;
+}
+function normalizeMetricPath(value) {
+    const segments = String(value ?? "")
+        .split(".")
+        .map((entry) => normalizeMetricSegment(entry))
+        .filter((entry) => entry.length > 0);
+    return segments.length ? segments.join(".") : "value";
+}
+function normalizeMetricSegment(value) {
+    let normalized = "";
+    let previousUnderscore = false;
+    for (const char of String(value ?? "")) {
+        if (/[A-Za-z0-9]/.test(char)) {
+            normalized += char.toLowerCase();
+            previousUnderscore = false;
+        }
+        else if (!previousUnderscore) {
+            normalized += "_";
+            previousUnderscore = true;
+        }
+    }
+    return normalized.replace(/^_+|_+$/g, "");
+}
+function isFiniteNumberLike(value) {
+    return (typeof value === "number" && Number.isFinite(value)) || typeof value === "bigint";
+}
+function toNumericValue(value) {
+    if (typeof value === "bigint") {
+        return Number(value);
+    }
+    return Number(value);
+}
+function inferUnitOfMeasure(fieldName) {
+    const normalized = fieldName.toLowerCase();
+    if (normalized.endsWith("_ms")) {
+        return "ms";
+    }
+    if (normalized.endsWith("_bytes") || normalized.endsWith("_byte")) {
+        return "bytes";
+    }
+    return undefined;
+}
+function buildDatadogLogEntry(options, event) {
+    const attributes = {
+        intake_type: "log",
+        event_type: event.eventType,
+        occurred_utc: event.occurredUtc.toISOString(),
+        session_id: event.sessionId,
+        test_suite: event.testSuite,
+        test_name: event.testName,
+        cluster_id: event.clusterId,
+        node_type: event.nodeType,
+        machine_name: event.machineName,
+        scenario_name: event.scenarioName,
+        step_name: event.stepName,
+        tags: event.tags,
+        fields: event.fields
+    };
+    for (const [key, value] of Object.entries(options.staticAttributes)) {
+        if (String(value ?? "").trim()) {
+            attributes[key] = value;
+        }
+    }
+    return {
+        message: toReportingSinkEventJson(event),
+        ddsource: options.source.trim() || "loadstrike",
+        service: options.service.trim() || "loadstrike",
+        hostname: options.host.trim() || event.machineName,
+        status: "info",
+        ddtags: buildDatadogTagString(event.tags, options.staticTags),
+        attributes
+    };
+}
+function buildDatadogTagString(eventTags, staticTags) {
+    const tags = {
+        source: "loadstrike"
+    };
+    for (const [key, value] of Object.entries(staticTags)) {
+        if (String(value ?? "").trim()) {
+            tags[key] = String(value);
+        }
+    }
+    for (const [key, value] of Object.entries(eventTags)) {
+        if (String(value ?? "").trim()) {
+            tags[key] = String(value);
+        }
+    }
+    return Object.entries(tags)
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([key, value]) => `${sanitizeDatadogTagComponent(key)}:${sanitizeDatadogTagComponent(value)}`)
+        .join(",");
+}
+function sanitizeDatadogTagComponent(value) {
+    return String(value ?? "")
+        .trim()
+        .split(":").join("_")
+        .split(",").join("_")
+        .split("|").join("_");
+}
+function buildSplunkBaseFields(options, intakeType) {
+    const fields = {
+        intake_type: intakeType
+    };
+    for (const [key, value] of Object.entries(options.staticFields)) {
+        if (String(value ?? "").trim()) {
+            fields[key] = String(value);
+        }
+    }
+    return fields;
+}
+function buildSplunkLogEnvelope(options, event) {
+    const fields = buildSplunkBaseFields(options, "log");
+    fields.event_type = event.eventType;
+    return {
+        time: toUnixSeconds(event.occurredUtc),
+        host: options.host.trim() || event.machineName,
+        source: options.source.trim() || "loadstrike",
+        sourcetype: options.sourcetype.trim() || "_json",
+        index: options.index.trim() || null,
+        event: {
+            intake_type: "log",
+            event_type: event.eventType,
+            occurred_utc: event.occurredUtc.toISOString(),
+            session_id: event.sessionId,
+            test_suite: event.testSuite,
+            test_name: event.testName,
+            cluster_id: event.clusterId,
+            node_type: event.nodeType,
+            machine_name: event.machineName,
+            scenario_name: event.scenarioName,
+            step_name: event.stepName,
+            tags: event.tags,
+            fields: event.fields
+        },
+        fields
+    };
+}
+function buildSplunkMetricEnvelope(options, point) {
+    const fields = buildSplunkBaseFields(options, "metric");
+    fields.metric_name = point.metricName;
+    fields.metric_kind = point.metricKind;
+    return {
+        time: toUnixSeconds(point.occurredUtc),
+        host: options.host.trim() || point.tags.machine_name || "local-machine",
+        source: options.source.trim() || "loadstrike",
+        sourcetype: options.sourcetype.trim() || "_json",
+        index: options.index.trim() || null,
+        event: {
+            intake_type: "metric",
+            metric_name: point.metricName,
+            metric_kind: point.metricKind,
+            occurred_utc: point.occurredUtc.toISOString(),
+            value: point.value,
+            unit_of_measure: point.unitOfMeasure ?? null,
+            tags: point.tags
+        },
+        fields
+    };
+}
+function buildOtelResourceAttributes(sinkName, staticAttributes) {
+    const attributes = {
+        "service.name": "loadstrike",
+        "service.namespace": "loadstrike",
+        "loadstrike.sink": sinkName
+    };
+    for (const [key, value] of Object.entries(staticAttributes)) {
+        if (String(value ?? "").trim()) {
+            attributes[key] = String(value);
+        }
+    }
+    return Object.entries(attributes)
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([key, value]) => ({
+        key,
+        value: { stringValue: value }
+    }));
+}
+function buildOtelLogRecord(event) {
+    return {
+        timeUnixNano: toUnixNanoseconds(event.occurredUtc),
+        observedTimeUnixNano: toUnixNanoseconds(event.occurredUtc),
+        severityText: "INFO",
+        body: { stringValue: toReportingSinkEventJson(event) },
+        attributes: buildOtelAttributes({
+            intake_type: "log",
+            event_type: event.eventType,
+            session_id: event.sessionId,
+            test_suite: event.testSuite,
+            test_name: event.testName,
+            cluster_id: event.clusterId,
+            node_type: event.nodeType,
+            machine_name: event.machineName,
+            scenario_name: event.scenarioName,
+            step_name: event.stepName,
+            tags: event.tags,
+            fields: event.fields
+        })
+    };
+}
+function buildOtelMetric(point, points) {
+    const dataPoints = points.map((entry) => buildOtelMetricDataPoint(entry));
+    return {
+        name: point.metricName,
+        description: "LoadStrike reporting sink metric projection",
+        unit: point.unitOfMeasure ?? null,
+        gauge: point.metricKind === "gauge" ? { dataPoints } : undefined,
+        sum: point.metricKind === "count" ? {
+            aggregationTemporality: 2,
+            isMonotonic: true,
+            dataPoints
+        } : undefined
+    };
+}
+function buildOtelMetricDataPoint(point) {
+    return {
+        timeUnixNano: toUnixNanoseconds(point.occurredUtc),
+        asDouble: point.value,
+        attributes: buildOtelAttributes({
+            ...point.tags,
+            intake_type: "metric",
+            metric_kind: point.metricKind
+        })
+    };
+}
+function buildOtelAttributes(values) {
+    return Object.entries(values)
+        .filter(([, value]) => value != null)
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([key, value]) => ({
+        key,
+        value: toOtelAnyValue(value)
+    }));
+}
+function toOtelAnyValue(value) {
+    if (value == null) {
+        return { stringValue: "" };
+    }
+    if (typeof value === "boolean") {
+        return { boolValue: value };
+    }
+    if (typeof value === "bigint") {
+        return { intValue: value.toString() };
+    }
+    if (typeof value === "number") {
+        return Number.isInteger(value)
+            ? { intValue: String(value) }
+            : { doubleValue: value };
+    }
+    if (value instanceof Date) {
+        return { stringValue: value.toISOString() };
+    }
+    if (typeof value === "object") {
+        return { stringValue: JSON.stringify(value) };
+    }
+    return { stringValue: String(value) };
+}
+function toUnixSeconds(value) {
+    return value.getTime() / 1000;
+}
+function sinkSessionMetadataFromContext(context, session) {
+    const nodeInfo = context.getNodeInfo?.() ?? context.nodeInfo;
+    const testInfo = context.testInfo;
+    const sessionStartedUtc = String(session?.startedUtc ?? session?.StartedUtc ?? "");
+    const contextStartedUtc = String(testInfo.createdUtc ?? testInfo.CreatedUtc ?? "");
+    return {
+        sessionId: String(testInfo.sessionId ?? ""),
+        testSuite: String(testInfo.testSuite ?? ""),
+        testName: String(testInfo.testName ?? ""),
+        clusterId: String(testInfo.clusterId ?? ""),
+        nodeType: String(nodeInfo.nodeType ?? "SingleNode"),
+        machineName: String(nodeInfo.machineName ?? ""),
+        startedUtc: sessionStartedUtc || contextStartedUtc || new Date().toISOString()
+    };
+}
+function readInfluxOptionsFromConfig(infraConfig, configurationSectionPath) {
+    const section = resolveConfigSection(infraConfig, configurationSectionPath);
+    return {
+        baseUrl: optionString(section, "BaseUrl", "baseUrl"),
+        writeEndpointPath: optionString(section, "WriteEndpointPath", "writeEndpointPath"),
+        organization: optionString(section, "Organization", "organization"),
+        bucket: optionString(section, "Bucket", "bucket"),
+        token: optionString(section, "Token", "token"),
+        measurementName: optionString(section, "MeasurementName", "measurementName"),
+        metricsMeasurementName: optionString(section, "MetricsMeasurementName", "metricsMeasurementName"),
+        timeoutSeconds: optionNumber(section, "TimeoutSeconds", "timeoutSeconds"),
+        timeoutMs: optionNumber(section, "TimeoutMs", "timeoutMs"),
+        staticTags: normalizeStringMap(optionRecord(section, "StaticTags", "staticTags"))
+    };
+}
+function readGrafanaLokiOptionsFromConfig(infraConfig, configurationSectionPath) {
+    const section = resolveConfigSection(infraConfig, configurationSectionPath);
+    return {
+        baseUrl: optionString(section, "BaseUrl", "baseUrl"),
+        pushEndpointPath: optionString(section, "PushEndpointPath", "pushEndpointPath"),
+        metricsBaseUrl: optionString(section, "MetricsBaseUrl", "metricsBaseUrl"),
+        metricsEndpointPath: optionString(section, "MetricsEndpointPath", "metricsEndpointPath"),
+        bearerToken: optionString(section, "BearerToken", "bearerToken"),
+        username: optionString(section, "Username", "username"),
+        password: optionString(section, "Password", "password"),
+        tenantId: optionString(section, "TenantId", "tenantId"),
+        timeoutSeconds: optionNumber(section, "TimeoutSeconds", "timeoutSeconds"),
+        timeoutMs: optionNumber(section, "TimeoutMs", "timeoutMs"),
+        staticLabels: normalizeStringMap(optionRecord(section, "StaticLabels", "staticLabels")),
+        metricsHeaders: normalizeStringMap(optionRecord(section, "MetricsHeaders", "metricsHeaders"))
+    };
+}
+function readTimescaleDbOptionsFromConfig(infraConfig, configurationSectionPath) {
+    const section = resolveConfigSection(infraConfig, configurationSectionPath);
+    return {
+        connectionString: optionString(section, "ConnectionString", "connectionString"),
+        schema: optionString(section, "Schema", "schema"),
+        tableName: optionString(section, "TableName", "tableName"),
+        metricsTableName: optionString(section, "MetricsTableName", "metricsTableName"),
+        staticTags: normalizeStringMap(optionRecord(section, "StaticTags", "staticTags"))
+    };
+}
+function readDatadogOptionsFromConfig(infraConfig, configurationSectionPath) {
+    const section = resolveConfigSection(infraConfig, configurationSectionPath);
+    return {
+        baseUrl: optionString(section, "BaseUrl", "baseUrl"),
+        logsEndpointPath: optionString(section, "LogsEndpointPath", "logsEndpointPath"),
+        metricsEndpointPath: optionString(section, "MetricsEndpointPath", "metricsEndpointPath"),
+        apiKey: optionString(section, "ApiKey", "apiKey"),
+        applicationKey: optionString(section, "ApplicationKey", "applicationKey"),
+        source: optionString(section, "Source", "source"),
+        service: optionString(section, "Service", "service"),
+        host: optionString(section, "Host", "host"),
+        timeoutSeconds: optionNumber(section, "TimeoutSeconds", "timeoutSeconds"),
+        timeoutMs: optionNumber(section, "TimeoutMs", "timeoutMs"),
+        staticTags: normalizeStringMap(optionRecord(section, "StaticTags", "staticTags")),
+        staticAttributes: normalizeStringMap(optionRecord(section, "StaticAttributes", "staticAttributes"))
+    };
+}
+function readSplunkOptionsFromConfig(infraConfig, configurationSectionPath) {
+    const section = resolveConfigSection(infraConfig, configurationSectionPath);
+    return {
+        baseUrl: optionString(section, "BaseUrl", "baseUrl"),
+        eventEndpointPath: optionString(section, "EventEndpointPath", "eventEndpointPath"),
+        token: optionString(section, "Token", "token"),
+        source: optionString(section, "Source", "source"),
+        sourcetype: optionString(section, "Sourcetype", "sourcetype"),
+        index: optionString(section, "Index", "index"),
+        host: optionString(section, "Host", "host"),
+        timeoutSeconds: optionNumber(section, "TimeoutSeconds", "timeoutSeconds"),
+        timeoutMs: optionNumber(section, "TimeoutMs", "timeoutMs"),
+        staticFields: normalizeStringMap(optionRecord(section, "StaticFields", "staticFields"))
+    };
+}
+function readOtelCollectorOptionsFromConfig(infraConfig, configurationSectionPath) {
+    const section = resolveConfigSection(infraConfig, configurationSectionPath);
+    return {
+        baseUrl: optionString(section, "BaseUrl", "baseUrl"),
+        logsEndpointPath: optionString(section, "LogsEndpointPath", "logsEndpointPath"),
+        metricsEndpointPath: optionString(section, "MetricsEndpointPath", "metricsEndpointPath"),
+        timeoutSeconds: optionNumber(section, "TimeoutSeconds", "timeoutSeconds"),
+        timeoutMs: optionNumber(section, "TimeoutMs", "timeoutMs"),
+        headers: normalizeStringMap(optionRecord(section, "Headers", "headers")),
+        staticResourceAttributes: normalizeStringMap(optionRecord(section, "StaticResourceAttributes", "staticResourceAttributes"))
+    };
+}
+function mergeInfluxOptions(target, source) {
+    if (!target.baseUrl.trim()) {
+        target.baseUrl = source.baseUrl?.trim() || "";
+    }
+    if (!target.writeEndpointPath.trim()) {
+        target.writeEndpointPath = source.writeEndpointPath?.trim() || "";
+    }
+    if (!target.organization.trim()) {
+        target.organization = source.organization?.trim() || "";
+    }
+    if (!target.bucket.trim()) {
+        target.bucket = source.bucket?.trim() || "";
+    }
+    if (!target.token.trim()) {
+        target.token = source.token?.trim() || "";
+    }
+    if (!target.measurementName.trim()) {
+        target.measurementName = source.measurementName?.trim() || "";
+    }
+    if (!target.metricsMeasurementName.trim()) {
+        target.metricsMeasurementName = source.metricsMeasurementName?.trim() || "";
+    }
+    if (resolveTimeoutMs(target.timeoutSeconds, target.timeoutMs) <= 0) {
+        target.timeoutSeconds = Number.isFinite(source.timeoutSeconds) ? Number(source.timeoutSeconds) : target.timeoutSeconds;
+        target.timeoutMs = Number.isFinite(source.timeoutMs) ? Number(source.timeoutMs) : target.timeoutMs;
+    }
+    if (Object.keys(target.staticTags).length === 0 && Object.keys(source.staticTags ?? {}).length > 0) {
+        target.staticTags = normalizeStringMap(source.staticTags);
+    }
+}
+function mergeGrafanaLokiOptions(target, source) {
+    if (!target.baseUrl.trim()) {
+        target.baseUrl = source.baseUrl?.trim() || "";
+    }
+    if (!target.pushEndpointPath.trim()) {
+        target.pushEndpointPath = source.pushEndpointPath?.trim() || "";
+    }
+    if (!target.metricsBaseUrl.trim()) {
+        target.metricsBaseUrl = source.metricsBaseUrl?.trim() || "";
+    }
+    if (!target.metricsEndpointPath.trim()) {
+        target.metricsEndpointPath = source.metricsEndpointPath?.trim() || "";
+    }
+    if (!target.bearerToken.trim()) {
+        target.bearerToken = source.bearerToken?.trim() || "";
+    }
+    if (!target.username.trim()) {
+        target.username = source.username?.trim() || "";
+    }
+    if (!target.password.trim()) {
+        target.password = source.password ?? "";
+    }
+    if (!target.tenantId.trim()) {
+        target.tenantId = source.tenantId?.trim() || "";
+    }
+    if (resolveTimeoutMs(target.timeoutSeconds, target.timeoutMs) <= 0) {
+        target.timeoutSeconds = Number.isFinite(source.timeoutSeconds) ? Number(source.timeoutSeconds) : target.timeoutSeconds;
+        target.timeoutMs = Number.isFinite(source.timeoutMs) ? Number(source.timeoutMs) : target.timeoutMs;
+    }
+    if (Object.keys(target.staticLabels).length === 0 && Object.keys(source.staticLabels ?? {}).length > 0) {
+        target.staticLabels = normalizeStringMap(source.staticLabels);
+    }
+    if (Object.keys(target.metricsHeaders).length === 0 && Object.keys(source.metricsHeaders ?? {}).length > 0) {
+        target.metricsHeaders = normalizeStringMap(source.metricsHeaders);
+    }
+}
+function mergeTimescaleDbOptions(target, source) {
+    if (!target.connectionString.trim()) {
+        target.connectionString = source.connectionString?.trim() || "";
+    }
+    if (!target.schema.trim()) {
+        target.schema = source.schema?.trim() || "";
+    }
+    if (!target.tableName.trim()) {
+        target.tableName = source.tableName?.trim() || "";
+    }
+    if (!target.metricsTableName.trim()) {
+        target.metricsTableName = source.metricsTableName?.trim() || "";
+    }
+    if (Object.keys(target.staticTags).length === 0 && Object.keys(source.staticTags ?? {}).length > 0) {
+        target.staticTags = normalizeStringMap(source.staticTags);
+    }
+}
+function mergeDatadogOptions(target, source) {
+    if (!target.baseUrl.trim()) {
+        target.baseUrl = source.baseUrl?.trim() || "";
+    }
+    if (!target.logsEndpointPath.trim()) {
+        target.logsEndpointPath = source.logsEndpointPath?.trim() || "";
+    }
+    if (!target.metricsEndpointPath.trim()) {
+        target.metricsEndpointPath = source.metricsEndpointPath?.trim() || "";
+    }
+    if (!target.apiKey.trim()) {
+        target.apiKey = source.apiKey?.trim() || "";
+    }
+    if (!target.applicationKey.trim()) {
+        target.applicationKey = source.applicationKey?.trim() || "";
+    }
+    if (!target.source.trim()) {
+        target.source = source.source?.trim() || "";
+    }
+    if (!target.service.trim()) {
+        target.service = source.service?.trim() || "";
+    }
+    if (!target.host.trim()) {
+        target.host = source.host?.trim() || "";
+    }
+    if (resolveTimeoutMs(target.timeoutSeconds, target.timeoutMs) <= 0) {
+        target.timeoutSeconds = Number.isFinite(source.timeoutSeconds) ? Number(source.timeoutSeconds) : target.timeoutSeconds;
+        target.timeoutMs = Number.isFinite(source.timeoutMs) ? Number(source.timeoutMs) : target.timeoutMs;
+    }
+    if (Object.keys(target.staticTags).length === 0 && Object.keys(source.staticTags ?? {}).length > 0) {
+        target.staticTags = normalizeStringMap(source.staticTags);
+    }
+    if (Object.keys(target.staticAttributes).length === 0 && Object.keys(source.staticAttributes ?? {}).length > 0) {
+        target.staticAttributes = normalizeStringMap(source.staticAttributes);
+    }
+}
+function mergeSplunkOptions(target, source) {
+    if (!target.baseUrl.trim()) {
+        target.baseUrl = source.baseUrl?.trim() || "";
+    }
+    if (!target.eventEndpointPath.trim()) {
+        target.eventEndpointPath = source.eventEndpointPath?.trim() || "";
+    }
+    if (!target.token.trim()) {
+        target.token = source.token?.trim() || "";
+    }
+    if (!target.source.trim()) {
+        target.source = source.source?.trim() || "";
+    }
+    if (!target.sourcetype.trim()) {
+        target.sourcetype = source.sourcetype?.trim() || "";
+    }
+    if (!target.index.trim()) {
+        target.index = source.index?.trim() || "";
+    }
+    if (!target.host.trim()) {
+        target.host = source.host?.trim() || "";
+    }
+    if (resolveTimeoutMs(target.timeoutSeconds, target.timeoutMs) <= 0) {
+        target.timeoutSeconds = Number.isFinite(source.timeoutSeconds) ? Number(source.timeoutSeconds) : target.timeoutSeconds;
+        target.timeoutMs = Number.isFinite(source.timeoutMs) ? Number(source.timeoutMs) : target.timeoutMs;
+    }
+    if (Object.keys(target.staticFields).length === 0 && Object.keys(source.staticFields ?? {}).length > 0) {
+        target.staticFields = normalizeStringMap(source.staticFields);
+    }
+}
+function mergeOtelCollectorOptions(target, source) {
+    if (!target.baseUrl.trim()) {
+        target.baseUrl = source.baseUrl?.trim() || "";
+    }
+    if (!target.logsEndpointPath.trim()) {
+        target.logsEndpointPath = source.logsEndpointPath?.trim() || "";
+    }
+    if (!target.metricsEndpointPath.trim()) {
+        target.metricsEndpointPath = source.metricsEndpointPath?.trim() || "";
+    }
+    if (resolveTimeoutMs(target.timeoutSeconds, target.timeoutMs) <= 0) {
+        target.timeoutSeconds = Number.isFinite(source.timeoutSeconds) ? Number(source.timeoutSeconds) : target.timeoutSeconds;
+        target.timeoutMs = Number.isFinite(source.timeoutMs) ? Number(source.timeoutMs) : target.timeoutMs;
+    }
+    if (Object.keys(target.headers).length === 0 && Object.keys(source.headers ?? {}).length > 0) {
+        target.headers = normalizeStringMap(source.headers);
+    }
+    if (Object.keys(target.staticResourceAttributes).length === 0 && Object.keys(source.staticResourceAttributes ?? {}).length > 0) {
+        target.staticResourceAttributes = normalizeStringMap(source.staticResourceAttributes);
+    }
+}
+function resolveConfigSection(source, path) {
+    const trimmedPath = String(path ?? "").trim();
+    if (!trimmedPath) {
+        return {};
+    }
+    const direct = pickRecordValue(source, trimmedPath);
+    if (isRecord(direct)) {
+        return direct;
+    }
+    const segments = trimmedPath.split(":").filter((value) => value.length > 0);
+    let current = source;
+    for (let index = 0; index < segments.length; index += 1) {
+        const currentRecord = asRecord(current);
+        const remainingPath = segments.slice(index).join(":");
+        const remaining = pickRecordValue(currentRecord, remainingPath);
+        if (isRecord(remaining)) {
+            return remaining;
+        }
+        const next = pickRecordValue(currentRecord, segments[index]);
+        if (!isRecord(next)) {
+            return {};
+        }
+        current = next;
+    }
+    return asRecord(current);
+}
+function pickRecordValue(record, ...keys) {
+    for (const key of keys) {
+        if (key in record) {
+            return record[key];
+        }
+        const normalizedKey = normalizeConfigKey(key);
+        const match = Object.entries(record).find(([entryKey]) => normalizeConfigKey(entryKey) === normalizedKey);
+        if (match) {
+            return match[1];
+        }
+    }
+    return undefined;
+}
+function optionString(record, ...keys) {
+    const value = pickRecordValue(record, ...keys);
+    return typeof value === "string" ? value : "";
+}
+function pickBooleanValue(record, fallback, ...keys) {
+    const value = pickRecordValue(record, ...keys);
+    if (typeof value === "boolean") {
+        return value;
+    }
+    if (typeof value === "number") {
+        return value !== 0;
+    }
+    if (typeof value === "string") {
+        const normalized = value.trim().toLowerCase();
+        if (normalized === "true" || normalized === "1" || normalized === "yes") {
+            return true;
+        }
+        if (normalized === "false" || normalized === "0" || normalized === "no") {
+            return false;
+        }
+    }
+    return fallback;
+}
+function optionNumber(record, ...keys) {
+    const value = pickRecordValue(record, ...keys);
+    if (typeof value === "number" && Number.isFinite(value)) {
+        return value;
+    }
+    if (typeof value === "string" && value.trim()) {
+        const parsed = Number(value);
+        if (Number.isFinite(parsed)) {
+            return parsed;
+        }
+    }
+    return undefined;
+}
+function optionRecord(record, ...keys) {
+    return asRecord(pickRecordValue(record, ...keys));
+}
+function normalizeStringMap(value) {
+    const resolved = asRecord(value);
+    const rows = {};
+    for (const [key, entryValue] of Object.entries(resolved)) {
+        if (entryValue == null) {
+            continue;
+        }
+        rows[key] = String(entryValue);
+    }
+    return rows;
+}
+function resolveTimeoutMs(timeoutSeconds, timeoutMs) {
+    if (Number.isFinite(timeoutMs) && Number(timeoutMs) > 0) {
+        return Math.max(Math.trunc(Number(timeoutMs)), 1);
+    }
+    if (Number.isFinite(timeoutSeconds) && Number(timeoutSeconds) > 0) {
+        return Math.max(Math.trunc(Number(timeoutSeconds) * 1000), 1);
+    }
+    return 30000;
+}
+function toUnixNanoseconds(value) {
+    return (BigInt(value.getTime()) * 1000000n).toString();
+}
+function escapeInfluxToken(value) {
+    return String(value ?? "")
+        .split("\\").join("\\\\")
+        .split(",").join("\\,")
+        .split(" ").join("\\ ")
+        .split("=").join("\\=");
+}
+function normalizePath(path) {
+    const trimmed = String(path ?? "").trim();
+    return trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
+}
+function trimTrailingSlashes(value) {
+    return value.replace(/\/+$/g, "");
+}
+function sanitizeGrafanaLabelKey(value) {
+    const sanitized = String(value ?? "")
+        .split("")
+        .map((char) => (/[A-Za-z0-9_]/.test(char) ? char : "_"))
+        .join("");
+    if (!sanitized || !/[A-Za-z_]/.test(sanitized[0])) {
+        return `_${sanitized}`;
+    }
+    return sanitized;
+}
+function sanitizeGrafanaLabelValue(value) {
+    return String(value ?? "").split("\r").join(" ").split("\n").join(" ").trim();
+}
+function replaceLiteral(value, search, replacement) {
+    return value.split(search).join(replacement);
+}
+function normalizePluginFieldName(value) {
+    const text = String(value ?? "").trim();
+    if (!text) {
+        return "value";
+    }
+    let normalized = "";
+    let lastWasUnderscore = false;
+    for (const char of text) {
+        if (/[A-Za-z0-9]/.test(char)) {
+            if (/[A-Z]/.test(char) && normalized && !lastWasUnderscore) {
+                normalized += "_";
+            }
+            normalized += char.toLowerCase();
+            lastWasUnderscore = false;
+        }
+        else if (!lastWasUnderscore) {
+            normalized += "_";
+            lastWasUnderscore = true;
+        }
+    }
+    return normalized.replace(/^_+|_+$/g, "") || "value";
+}
+function normalizePluginFieldValue(value) {
+    if (value == null || typeof value === "string" || typeof value === "boolean" || typeof value === "number") {
+        return value;
+    }
+    if (typeof value === "bigint") {
+        return Number(value);
+    }
+    if (value instanceof Date) {
+        return value.toISOString();
+    }
+    return JSON.stringify(value);
+}
+function tryReadText(row, key) {
+    const value = pickRecordValue(row, key, key.toLowerCase(), key.toUpperCase());
+    if (value == null) {
+        return null;
+    }
+    const text = String(value).trim();
+    return text || null;
+}
+function cleanNullableText(value) {
+    const text = String(value ?? "").trim();
+    return text || null;
+}
+function validateIdentifier(value, parameterName) {
+    if (!IDENTIFIER_REGEX.test(value)) {
+        throw new Error(`TimescaleDbReportingSink ${parameterName} '${value}' contains unsupported characters.`);
+    }
+}
+function quoteIdentifier(schema, tableName) {
+    return `${quoteIdentifierPart(schema)}.${quoteIdentifierPart(tableName)}`;
+}
+function quoteIdentifierPart(value) {
+    return `"${value}"`;
+}
+function normalizeConfigKey(value) {
+    return String(value ?? "").replace(/[^A-Za-z0-9]+/g, "").toLowerCase();
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function asRecord(value) {
+    return isRecord(value) ? value : {};
+}
+function cloneBaseContext(context) {
+    const nodeInfo = cloneNodeInfo(context.nodeInfo);
+    const testInfo = cloneTestInfo(context.testInfo);
+    return {
+        logger: context.logger,
+        nodeInfo,
+        testInfo,
+        getNodeInfo: () => cloneNodeInfo(context.getNodeInfo?.() ?? nodeInfo)
+    };
+}
+function cloneSessionStartInfo(session) {
+    return {
+        ...cloneBaseContext(session),
+        startedUtc: session.startedUtc,
+        scenarioNames: [...session.scenarioNames],
+        scenarios: session.scenarios.map((value) => ({ ...value }))
+    };
+}
+function cloneNodeInfo(nodeInfo) {
+    return { ...nodeInfo };
+}
+function cloneTestInfo(testInfo) {
+    return { ...testInfo };
+}
+function cloneMetricStats(metrics) {
+    return {
+        counters: metrics.counters.map((value) => ({ ...value })),
+        gauges: metrics.gauges.map((value) => ({ ...value })),
+        durationMs: metrics.durationMs
+    };
+}
+function cloneScenarioStats(value) {
+    return {
+        ...value,
+        ok: deepCloneRecord(value.ok),
+        fail: deepCloneRecord(value.fail),
+        loadSimulationStats: { ...value.loadSimulationStats },
+        stepStats: value.stepStats.map((step) => ({
+            ...step,
+            ok: deepCloneRecord(step.ok),
+            fail: deepCloneRecord(step.fail)
+        }))
+    };
+}
+function cloneNodeStats(result) {
+    return {
+        ...result,
+        nodeInfo: cloneNodeInfo(result.nodeInfo),
+        testInfo: cloneTestInfo(result.testInfo),
+        thresholds: result.thresholds.map((value) => ({ ...value })),
+        thresholdResults: result.thresholdResults.map((value) => ({ ...value })),
+        metrics: cloneMetricStats(result.metrics),
+        metricValues: result.metricValues.map((value) => ({ ...value })),
+        scenarioStats: result.scenarioStats.map((value) => cloneScenarioStats(value)),
+        stepStats: result.stepStats.map((step) => ({
+            ...step,
+            ok: deepCloneRecord(step.ok),
+            fail: deepCloneRecord(step.fail)
+        })),
+        pluginsData: result.pluginsData.map((plugin) => new LoadStrikePluginDataModel(plugin.pluginName, plugin.tables.map((table) => new LoadStrikePluginDataTableModel(table.tableName, [...table.headers], table.rows.map((row) => deepCloneRecord(row)))), [...plugin.hints])),
+        disabledSinks: [...result.disabledSinks],
+        sinkErrors: result.sinkErrors.map((value) => ({ ...value })),
+        reportFiles: [...result.reportFiles]
+    };
+}
+function deepCloneRecord(value) {
+    const source = asRecord(value);
+    const result = {};
+    for (const [key, entryValue] of Object.entries(source)) {
+        result[key] = deepCloneValue(entryValue);
+    }
+    return result;
+}
+function deepCloneValue(value) {
+    if (Array.isArray(value)) {
+        return value.map((entry) => deepCloneValue(entry));
+    }
+    if (isRecord(value)) {
+        return deepCloneRecord(value);
+    }
+    return value;
+}
+async function postWithTimeout(fetchImpl, url, init, timeoutMs, sinkName) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), Math.max(timeoutMs, 1));
+    try {
+        const response = await fetchImpl(url, { ...init, signal: controller.signal });
+        if (!response.ok) {
+            const body = await response.text();
+            throw new Error(`${sinkName} write failed with status ${response.status}: ${body}`);
+        }
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}