@loadstrike/loadstrike-sdk 1.0.26901 → 1.0.27301

package/dist/esm/sinks.js

@@ -1,5 +1,8 @@
 import { LoadStrikePluginData as LoadStrikePluginDataModel, LoadStrikePluginDataTable as LoadStrikePluginDataTableModel } from "./runtime.js";
 import { createHash, randomBytes } from "node:crypto";
+import { appendFileSync, mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+import { createSocket } from "node:dgram";
 import { Pool } from "pg";
 const DEFAULT_INFLUX_CONFIGURATION_SECTION_PATH = "LoadStrike:ReportingSinks:InfluxDb";
 const DEFAULT_GRAFANA_LOKI_CONFIGURATION_SECTION_PATH = "LoadStrike:ReportingSinks:GrafanaLoki";
@@ -1364,6 +1367,226 @@ export class OtelCollectorReportingSink {
         }, resolveTimeoutMs(this.options.timeoutSeconds, this.options.timeoutMs), "OtelCollectorReportingSink metrics");
     }
 }
+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);
+    }
+}
+export class PrometheusRemoteWriteReportingSink extends ExpandedHttpJsonReportingSink {
+    constructor(options = {}) {
+        super("prometheus-remote-write", "extensions.reporting_sinks.prometheus_remote_write", "/api/v1/write", options);
+    }
+}
+export class CloudWatchReportingSink extends ExpandedHttpJsonReportingSink {
+    constructor(options = {}) {
+        super("cloudwatch", "extensions.reporting_sinks.cloudwatch", "/loadstrike/events", options);
+    }
+}
+export class DynatraceReportingSink extends ExpandedHttpJsonReportingSink {
+    constructor(options = {}) {
+        super("dynatrace", "extensions.reporting_sinks.dynatrace", "/api/v2/logs/ingest", options);
+    }
+}
+export class ElasticsearchReportingSink extends ExpandedHttpJsonReportingSink {
+    constructor(options = {}) {
+        super("elasticsearch", "extensions.reporting_sinks.elasticsearch", "/loadstrike-events/_doc", options);
+    }
+}
+export class OpenSearchReportingSink extends ExpandedHttpJsonReportingSink {
+    constructor(options = {}) {
+        super("opensearch", "extensions.reporting_sinks.opensearch", "/loadstrike-events/_doc", options);
+    }
+}
+export class NewRelicReportingSink extends ExpandedHttpJsonReportingSink {
+    constructor(options = {}) {
+        super("new-relic", "extensions.reporting_sinks.new_relic", "/log/v1", options);
+    }
+}
+export class GenericWebhookReportingSink extends ExpandedHttpJsonReportingSink {
+    constructor(options = {}) {
+        super("webhook", "extensions.reporting_sinks.webhook", "/loadstrike", options);
+    }
+}
+export 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)));
+    }
+}
+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);
+    }
+}
+export class StatsDReportingSink extends StatsDReportingSinkBase {
+    constructor(options = {}) {
+        super("statsd", "extensions.reporting_sinks.statsd", options, false);
+    }
+}
+export class DogStatsDReportingSink extends StatsDReportingSinkBase {
+    constructor(options = {}) {
+        super("dogstatsd", "extensions.reporting_sinks.dogstatsd", options, true);
+    }
+}
+export class NetdataStatsDReportingSink extends StatsDReportingSinkBase {
+    constructor(options = {}) {
+        super("netdata-statsd", "extensions.reporting_sinks.netdata", options, false);
+    }
+}
+export 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;
+        }
+        mkdirSync(dirname(this.filePath), { recursive: true });
+        appendFileSync(this.filePath, `${JSON.stringify(this.buildPayload(events, this.staticTags))}\n`, "utf8");
+    }
+}
 function createRealtimeStatsEvents(session, scenarios) {
     const occurredUtc = new Date();
     const events = [];
@@ -2577,6 +2800,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 = 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);