@loadstrike/loadstrike-sdk 1.0.26901 → 1.0.27301

package/dist/cjs/sinks.js

@@ -1,9 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.__loadstrikeTestExports = exports.OtelCollectorReportingSink = exports.SplunkReportingSink = exports.DatadogReportingSink = exports.TimescaleDbReportingSink = exports.GrafanaLokiReportingSink = exports.InfluxDbReportingSink = exports.PortalReportingSink = exports.CompositeReportingSink = exports.ConsoleReportingSink = exports.MemoryReportingSink = exports.OtelCollectorReportingSinkOptions = exports.SplunkReportingSinkOptions = exports.DatadogReportingSinkOptions = exports.TimescaleDbReportingSinkOptions = exports.GrafanaLokiReportingSinkOptions = exports.InfluxDbReportingSinkOptions = void 0;
+exports.__loadstrikeTestExports = exports.JsonlFileReportingSink = exports.NetdataStatsDReportingSink = exports.DogStatsDReportingSink = exports.StatsDReportingSink = exports.KafkaReportingSink = exports.GenericWebhookReportingSink = exports.NewRelicReportingSink = exports.OpenSearchReportingSink = exports.ElasticsearchReportingSink = exports.DynatraceReportingSink = exports.CloudWatchReportingSink = exports.PrometheusRemoteWriteReportingSink = exports.OtelCollectorReportingSink = exports.SplunkReportingSink = exports.DatadogReportingSink = exports.TimescaleDbReportingSink = exports.GrafanaLokiReportingSink = exports.InfluxDbReportingSink = exports.PortalReportingSink = exports.CompositeReportingSink = exports.ConsoleReportingSink = exports.MemoryReportingSink = exports.OtelCollectorReportingSinkOptions = exports.SplunkReportingSinkOptions = exports.DatadogReportingSinkOptions = exports.TimescaleDbReportingSinkOptions = exports.GrafanaLokiReportingSinkOptions = exports.InfluxDbReportingSinkOptions = void 0;
 exports.cloneReportingSinkForRun = cloneReportingSinkForRun;
 const runtime_js_1 = require("./runtime.js");
 const node_crypto_1 = require("node:crypto");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const node_dgram_1 = require("node:dgram");
 const pg_1 = require("pg");
 const DEFAULT_INFLUX_CONFIGURATION_SECTION_PATH = "LoadStrike:ReportingSinks:InfluxDb";
 const DEFAULT_GRAFANA_LOKI_CONFIGURATION_SECTION_PATH = "LoadStrike:ReportingSinks:GrafanaLoki";
@@ -1384,6 +1387,238 @@ class OtelCollectorReportingSink {
     }
 }
 exports.OtelCollectorReportingSink = OtelCollectorReportingSink;
+class ExpandedEventReportingSink {
+    constructor(sinkName, licenseFeature) {
+        this.baseContext = null;
+        this.session = null;
+        this.sinkName = sinkName;
+        this.SinkName = sinkName;
+        this.licenseFeature = licenseFeature;
+        this.LicenseFeature = licenseFeature;
+    }
+    init(context, _infraConfig) {
+        this.baseContext = cloneBaseContext(context);
+    }
+    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 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;
+    }
+    buildPayload(events, staticTags = {}) {
+        return {
+            sinkName: this.sinkName,
+            runId: this.getSession().runId,
+            sessionId: this.getSession().sessionId,
+            events: events.map((event) => ({
+                ...event,
+                tags: { ...staticTags, ...event.tags }
+            })),
+            metrics: createReportingSinkMetricPoints(this.sinkName, events, staticTags)
+        };
+    }
+}
+class ExpandedHttpJsonReportingSink extends ExpandedEventReportingSink {
+    constructor(sinkName, licenseFeature, defaultEndpointPath, options = {}) {
+        super(sinkName, licenseFeature);
+        const source = asRecord(options);
+        this.baseUrl = optionString(source, "baseUrl", "BaseUrl").trim();
+        this.endpointPath = optionString(source, "endpointPath", "EndpointPath").trim() || defaultEndpointPath;
+        this.headers = normalizeStringMap(optionRecord(source, "headers", "Headers"));
+        this.staticTags = normalizeStringMap(optionRecord(source, "staticTags", "StaticTags"));
+        this.timeoutMs = resolveTimeoutMs(optionNumber(source, "timeoutSeconds", "TimeoutSeconds"), optionNumber(source, "timeoutMs", "TimeoutMs"));
+        this.fetchImpl = pickRecordValue(source, "fetchImpl", "FetchImpl") ?? fetch;
+    }
+    init(context, infraConfig) {
+        super.init(context, infraConfig);
+        if (!this.baseUrl.trim()) {
+            throw new Error(`${this.constructor.name} requires BaseUrl.`);
+        }
+    }
+    async persistEvents(events) {
+        if (!events.length) {
+            return;
+        }
+        await postWithTimeout(this.fetchImpl, `${trimTrailingSlashes(this.baseUrl)}${normalizePath(this.endpointPath)}`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                ...this.headers
+            },
+            body: JSON.stringify(this.buildPayload(events, this.staticTags))
+        }, this.timeoutMs, this.constructor.name);
+    }
+}
+class PrometheusRemoteWriteReportingSink extends ExpandedHttpJsonReportingSink {
+    constructor(options = {}) {
+        super("prometheus-remote-write", "extensions.reporting_sinks.prometheus_remote_write", "/api/v1/write", options);
+    }
+}
+exports.PrometheusRemoteWriteReportingSink = PrometheusRemoteWriteReportingSink;
+class CloudWatchReportingSink extends ExpandedHttpJsonReportingSink {
+    constructor(options = {}) {
+        super("cloudwatch", "extensions.reporting_sinks.cloudwatch", "/loadstrike/events", options);
+    }
+}
+exports.CloudWatchReportingSink = CloudWatchReportingSink;
+class DynatraceReportingSink extends ExpandedHttpJsonReportingSink {
+    constructor(options = {}) {
+        super("dynatrace", "extensions.reporting_sinks.dynatrace", "/api/v2/logs/ingest", options);
+    }
+}
+exports.DynatraceReportingSink = DynatraceReportingSink;
+class ElasticsearchReportingSink extends ExpandedHttpJsonReportingSink {
+    constructor(options = {}) {
+        super("elasticsearch", "extensions.reporting_sinks.elasticsearch", "/loadstrike-events/_doc", options);
+    }
+}
+exports.ElasticsearchReportingSink = ElasticsearchReportingSink;
+class OpenSearchReportingSink extends ExpandedHttpJsonReportingSink {
+    constructor(options = {}) {
+        super("opensearch", "extensions.reporting_sinks.opensearch", "/loadstrike-events/_doc", options);
+    }
+}
+exports.OpenSearchReportingSink = OpenSearchReportingSink;
+class NewRelicReportingSink extends ExpandedHttpJsonReportingSink {
+    constructor(options = {}) {
+        super("new-relic", "extensions.reporting_sinks.new_relic", "/log/v1", options);
+    }
+}
+exports.NewRelicReportingSink = NewRelicReportingSink;
+class GenericWebhookReportingSink extends ExpandedHttpJsonReportingSink {
+    constructor(options = {}) {
+        super("webhook", "extensions.reporting_sinks.webhook", "/loadstrike", options);
+    }
+}
+exports.GenericWebhookReportingSink = GenericWebhookReportingSink;
+class KafkaReportingSink extends ExpandedEventReportingSink {
+    constructor(options = {}) {
+        super("kafka", "extensions.reporting_sinks.kafka");
+        const source = asRecord(options);
+        this.topic = optionString(source, "topic", "Topic").trim() || "loadstrike-events";
+        this.staticTags = normalizeStringMap(optionRecord(source, "staticTags", "StaticTags"));
+        this.publishAsync = pickRecordValue(source, "publishAsync", "PublishAsync");
+    }
+    async persistEvents(events) {
+        if (!events.length) {
+            return;
+        }
+        if (!this.publishAsync) {
+            throw new Error("KafkaReportingSink requires PublishAsync when a Kafka producer is not configured by the host application.");
+        }
+        await this.publishAsync(this.topic, JSON.stringify(this.buildPayload(events, this.staticTags)));
+    }
+}
+exports.KafkaReportingSink = KafkaReportingSink;
+class StatsDReportingSinkBase extends ExpandedEventReportingSink {
+    constructor(sinkName, licenseFeature, options = {}, dogStatsD = false) {
+        super(sinkName, licenseFeature);
+        const source = asRecord(options);
+        this.prefix = optionString(source, "prefix", "Prefix").trim() || "loadstrike";
+        this.host = optionString(source, "host", "Host").trim() || "127.0.0.1";
+        this.port = optionNumber(source, "port", "Port") ?? 8125;
+        this.tags = normalizeStringMap(optionRecord(source, "tags", "Tags"));
+        this.sendLineAsync = pickRecordValue(source, "sendLineAsync", "SendLineAsync");
+        this.dogStatsD = dogStatsD;
+    }
+    async persistEvents(events) {
+        const points = createReportingSinkMetricPoints(this.sinkName, events, this.tags);
+        for (const point of points) {
+            await this.sendLine(this.formatPoint(point));
+        }
+    }
+    formatPoint(point) {
+        const metricType = point.metricKind === "count" ? "c" : "g";
+        const tagSuffix = this.dogStatsD
+            ? dogStatsDTagSuffix({ ...this.tags, ...point.tags })
+            : "";
+        return `${this.prefix}.${sanitizeMetricToken(point.metricName)}:${point.value}|${metricType}${tagSuffix}`;
+    }
+    async sendLine(line) {
+        if (this.sendLineAsync) {
+            await this.sendLineAsync(line);
+            return;
+        }
+        await sendStatsDUdpLine(this.host, this.port, line);
+    }
+}
+class StatsDReportingSink extends StatsDReportingSinkBase {
+    constructor(options = {}) {
+        super("statsd", "extensions.reporting_sinks.statsd", options, false);
+    }
+}
+exports.StatsDReportingSink = StatsDReportingSink;
+class DogStatsDReportingSink extends StatsDReportingSinkBase {
+    constructor(options = {}) {
+        super("dogstatsd", "extensions.reporting_sinks.dogstatsd", options, true);
+    }
+}
+exports.DogStatsDReportingSink = DogStatsDReportingSink;
+class NetdataStatsDReportingSink extends StatsDReportingSinkBase {
+    constructor(options = {}) {
+        super("netdata-statsd", "extensions.reporting_sinks.netdata", options, false);
+    }
+}
+exports.NetdataStatsDReportingSink = NetdataStatsDReportingSink;
+class JsonlFileReportingSink extends ExpandedEventReportingSink {
+    constructor(options = {}) {
+        super("jsonl", "extensions.reporting_sinks.jsonl");
+        const source = asRecord(options);
+        this.filePath = optionString(source, "filePath", "FilePath").trim() || "loadstrike-reporting.jsonl";
+        this.staticTags = normalizeStringMap(optionRecord(source, "staticTags", "StaticTags"));
+    }
+    async persistEvents(events) {
+        if (!events.length) {
+            return;
+        }
+        (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(this.filePath), { recursive: true });
+        (0, node_fs_1.appendFileSync)(this.filePath, `${JSON.stringify(this.buildPayload(events, this.staticTags))}\n`, "utf8");
+    }
+}
+exports.JsonlFileReportingSink = JsonlFileReportingSink;
 function createRealtimeStatsEvents(session, scenarios) {
     const occurredUtc = new Date();
     const events = [];
@@ -2597,6 +2832,32 @@ function normalizeStringMap(value) {
     }
     return rows;
 }
+function sanitizeMetricToken(value) {
+    return String(value ?? "")
+        .trim()
+        .replace(/[^A-Za-z0-9_.-]+/g, "_")
+        .replace(/^_+|_+$/g, "") || "metric";
+}
+function dogStatsDTagSuffix(tags) {
+    const values = Object.entries(tags)
+        .filter(([key]) => key.trim().length > 0)
+        .map(([key, value]) => `${sanitizeMetricToken(key)}:${String(value ?? "").replace(/[,|]+/g, "_")}`);
+    return values.length ? `|#${values.join(",")}` : "";
+}
+function sendStatsDUdpLine(host, port, line) {
+    return new Promise((resolve, reject) => {
+        const socket = (0, node_dgram_1.createSocket)("udp4");
+        const payload = Buffer.from(line, "utf8");
+        socket.send(payload, port, host, (error) => {
+            socket.close();
+            if (error) {
+                reject(error);
+                return;
+            }
+            resolve();
+        });
+    });
+}
 function resolveTimeoutMs(timeoutSeconds, timeoutMs) {
     if (Number.isFinite(timeoutMs) && Number(timeoutMs) > 0) {
         return Math.max(Math.trunc(Number(timeoutMs)), 1);