@loadstrike/loadstrike-sdk 1.0.27101 → 1.0.27301

package/dist/esm/runtime.js

@@ -1606,6 +1606,169 @@ export class LoadStrikeContext {
 }
 const ACCESSIBILITY_TESTING_FEATURE = "testing.accessibility";
 const BROWSER_WEB_VITALS_FEATURE = "testing.browser_web_vitals";
+export class LoadStrikeAccessibilityBaseline {
+    constructor(initial = {}) {
+        const source = qualityRecord(initial);
+        this.allowedRuleIds = qualityStringArray(qualityValue(source, "allowedRuleIds", "AllowedRuleIds"));
+        this.AllowedRuleIds = this.allowedRuleIds;
+        this.maxNewViolations = Math.max(0, qualityNumber(source, 0, "maxNewViolations", "MaxNewViolations"));
+        this.MaxNewViolations = this.maxNewViolations;
+    }
+    compare(result) {
+        const violations = Array.isArray(result?.violations) ? result.violations : [];
+        const allowed = new Set(this.allowedRuleIds.map((value) => value.toLowerCase()));
+        const newViolations = violations.filter((violation) => !allowed.has(String(violation.ruleId ?? "").toLowerCase()));
+        const newRuleIds = Array.from(new Set(newViolations
+            .map((violation) => String(violation.ruleId ?? "").trim())
+            .filter(Boolean)));
+        return {
+            passed: newViolations.length <= this.maxNewViolations,
+            Passed: newViolations.length <= this.maxNewViolations,
+            newViolationCount: newViolations.length,
+            NewViolationCount: newViolations.length,
+            newRuleIds,
+            NewRuleIds: newRuleIds
+        };
+    }
+    Compare(result) {
+        return this.compare(result);
+    }
+}
+export class LoadStrikeAccessibilityCiGate {
+    constructor(initial = {}) {
+        const source = qualityRecord(initial);
+        this.maxViolations = qualityOptionalNumber(source, "maxViolations", "MaxViolations");
+        this.MaxViolations = this.maxViolations;
+        this.maxCriticalViolations = qualityOptionalNumber(source, "maxCriticalViolations", "MaxCriticalViolations");
+        this.MaxCriticalViolations = this.maxCriticalViolations;
+        this.maxSeriousViolations = qualityOptionalNumber(source, "maxSeriousViolations", "MaxSeriousViolations");
+        this.MaxSeriousViolations = this.maxSeriousViolations;
+        const baseline = qualityValue(source, "baseline", "Baseline");
+        this.baseline = baseline instanceof LoadStrikeAccessibilityBaseline
+            ? baseline
+            : (baseline && typeof baseline === "object" ? new LoadStrikeAccessibilityBaseline(baseline) : undefined);
+        this.Baseline = this.baseline;
+    }
+    evaluate(result) {
+        const normalized = attachAccessibilityCounts(result);
+        const reasons = [];
+        if (this.maxViolations != null && (normalized.totalViolations ?? 0) > this.maxViolations) {
+            reasons.push(`total accessibility violations ${normalized.totalViolations} exceeded ${this.maxViolations}.`);
+        }
+        if (this.maxCriticalViolations != null && (normalized.criticalViolations ?? 0) > this.maxCriticalViolations) {
+            reasons.push(`critical accessibility violations ${normalized.criticalViolations} exceeded ${this.maxCriticalViolations}.`);
+        }
+        if (this.maxSeriousViolations != null && (normalized.seriousViolations ?? 0) > this.maxSeriousViolations) {
+            reasons.push(`serious accessibility violations ${normalized.seriousViolations} exceeded ${this.maxSeriousViolations}.`);
+        }
+        if (this.baseline) {
+            const baseline = this.baseline.compare(normalized);
+            if (!baseline.passed) {
+                reasons.push(`baseline found ${baseline.newViolationCount} new accessibility violation(s).`);
+            }
+        }
+        return {
+            passed: reasons.length === 0,
+            Passed: reasons.length === 0,
+            reasons,
+            Reasons: reasons
+        };
+    }
+    Evaluate(result) {
+        return this.evaluate(result);
+    }
+}
+export class LoadStrikeAccessibilityScanner {
+    static scanHtml(options, html) {
+        validateAbsoluteUrl(options?.url, "Accessibility check URL");
+        const source = String(html ?? "");
+        const violations = [];
+        if (!/<html\b[^>]*\blang\s*=\s*["'][^"']+["']/i.test(source)) {
+            violations.push(createAccessibilityViolation("html-has-lang", "serious", "The html element should declare a non-empty language."));
+        }
+        if (/<title\b[^>]*>\s*<\/title>/i.test(source) || !/<title\b/i.test(source)) {
+            violations.push(createAccessibilityViolation("document-title", "serious", "The page should provide a useful title."));
+        }
+        for (const match of source.matchAll(/<img\b(?![^>]*\balt\s*=)[^>]*>/gi)) {
+            violations.push(createAccessibilityViolation("image-alt", "serious", "Images should provide alternate text.", match[0]));
+        }
+        for (const match of source.matchAll(/<button\b(?![^>]*\baria-label\s*=)[^>]*>\s*<\/button>/gi)) {
+            violations.push(createAccessibilityViolation("button-name", "critical", "Buttons should have an accessible name.", match[0]));
+        }
+        for (const match of source.matchAll(/<input\b(?![^>]*\baria-label\s*=)[^>]*\bid\s*=\s*["']?([a-zA-Z0-9_-]+)["']?[^>]*>/gi)) {
+            const id = match[1] ?? "";
+            const labelRegex = new RegExp(`<label\\b[^>]*\\bfor\\s*=\\s*["']?${escapeRegExp(id)}["']?[^>]*>`, "i");
+            if (!labelRegex.test(source)) {
+                violations.push(createAccessibilityViolation("label", "critical", "Form fields should have labels.", match[0]));
+            }
+        }
+        const focusOrder = [...source.matchAll(/<(a|button|input|select|textarea)\b[^>]*>/gi)]
+            .map((match) => match[0]);
+        const visibleFocusFailures = focusOrder.filter((element) => /outline\s*:\s*(none|0)\b/i.test(element)).length;
+        const missingSkipLinkCount = /href\s*=\s*["']#(main|content)["']/i.test(source) ? 0 : 1;
+        if (visibleFocusFailures > 0) {
+            violations.push(createAccessibilityViolation("focus-visible", "serious", "Keyboard focus indicators should remain visible."));
+        }
+        if (missingSkipLinkCount > 0) {
+            violations.push(createAccessibilityViolation("skip-link", "moderate", "Pages should provide a skip link to the main content."));
+        }
+        return attachAccessibilityCounts({
+            url: options.url,
+            violations,
+            keyboardFocus: {
+                tabbableElementCount: focusOrder.length,
+                visibleFocusFailures,
+                missingSkipLinkCount,
+                focusOrder
+            }
+        });
+    }
+    static ScanHtml(options, html) {
+        return LoadStrikeAccessibilityScanner.scanHtml(options, html);
+    }
+}
+export class LoadStrikeAccessibilityAdapters {
+    static async fromPlaywrightPageAsync(options, page) {
+        const html = await readBrowserContent(page, ["ContentAsync", "contentAsync", "content"]);
+        return LoadStrikeAccessibilityScanner.scanHtml(options, html);
+    }
+    static FromPlaywrightPageAsync(options, page) {
+        return LoadStrikeAccessibilityAdapters.fromPlaywrightPageAsync(options, page);
+    }
+    static fromSeleniumDriver(options, driver) {
+        const record = qualityRecord(driver);
+        const html = String(qualityValue(record, "PageSource", "pageSource") ?? "");
+        return LoadStrikeAccessibilityScanner.scanHtml(options, html);
+    }
+    static FromSeleniumDriver(options, driver) {
+        return LoadStrikeAccessibilityAdapters.fromSeleniumDriver(options, driver);
+    }
+}
+export class LoadStrikeBrowserWebVitalsCollector {
+    static fromPerformanceSnapshot(options, snapshot) {
+        validateAbsoluteUrl(options?.url, "Browser Web Vitals URL");
+        return normalizeWebVitalsSnapshot(options.url, snapshot);
+    }
+    static FromPerformanceSnapshot(options, snapshot) {
+        return LoadStrikeBrowserWebVitalsCollector.fromPerformanceSnapshot(options, snapshot);
+    }
+    static async fromPlaywrightPageAsync(options, page) {
+        validateAbsoluteUrl(options?.url, "Browser Web Vitals URL");
+        const snapshot = await invokeBrowserMethod(page, ["EvaluateAsync", "evaluate"], WEB_VITALS_SCRIPT);
+        return normalizeWebVitalsSnapshot(options.url, snapshot);
+    }
+    static FromPlaywrightPageAsync(options, page) {
+        return LoadStrikeBrowserWebVitalsCollector.fromPlaywrightPageAsync(options, page);
+    }
+    static fromSeleniumDriver(options, driver) {
+        validateAbsoluteUrl(options?.url, "Browser Web Vitals URL");
+        const snapshot = invokeBrowserMethodSync(driver, ["ExecuteScript", "executeScript"], WEB_VITALS_SCRIPT);
+        return normalizeWebVitalsSnapshot(options.url, snapshot);
+    }
+    static FromSeleniumDriver(options, driver) {
+        return LoadStrikeBrowserWebVitalsCollector.fromSeleniumDriver(options, driver);
+    }
+}
 export class LoadStrikeAccessibility {
     static createScenario(name, options, check) {
         if (typeof name !== "string" || !name.trim()) {
@@ -1654,6 +1817,129 @@ export class LoadStrikeBrowserWebVitals {
         return LoadStrikeBrowserWebVitals.createScenario(name, options, measure);
     }
 }
+const WEB_VITALS_SCRIPT = `
+(() => {
+  const navigation = performance.getEntriesByType("navigation")[0];
+  const paint = performance.getEntriesByType("paint");
+  const fcp = paint.find((entry) => entry.name === "first-contentful-paint");
+  return {
+    largestContentfulPaintMs: globalThis.__loadstrikeLcp ?? 0,
+    interactionToNextPaintMs: globalThis.__loadstrikeInp ?? 0,
+    cumulativeLayoutShift: globalThis.__loadstrikeCls ?? 0,
+    firstContentfulPaintMs: fcp ? fcp.startTime : 0,
+    timeToFirstByteMs: navigation ? navigation.responseStart : 0
+  };
+})()
+`;
+function createAccessibilityViolation(ruleId, impact, description, target) {
+    return {
+        ruleId,
+        impact,
+        description,
+        helpUrl: `https://www.w3.org/WAI/WCAG22/quickref/?versions=2.2#${ruleId}`,
+        targets: target ? [target] : []
+    };
+}
+function attachAccessibilityCounts(result) {
+    const violations = Array.isArray(result?.violations) ? result.violations : [];
+    return {
+        ...result,
+        violations,
+        totalViolations: violations.length,
+        criticalViolations: countAccessibilityImpact(violations, "critical"),
+        seriousViolations: countAccessibilityImpact(violations, "serious"),
+        moderateViolations: countAccessibilityImpact(violations, "moderate"),
+        minorViolations: countAccessibilityImpact(violations, "minor")
+    };
+}
+function qualityRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : {};
+}
+function qualityValue(record, ...keys) {
+    for (const key of keys) {
+        if (key in record) {
+            return record[key];
+        }
+        const normalized = key.toLowerCase();
+        const match = Object.entries(record).find(([entryKey]) => entryKey.toLowerCase() === normalized);
+        if (match) {
+            return match[1];
+        }
+    }
+    return undefined;
+}
+function qualityStringArray(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.map((entry) => String(entry ?? "").trim()).filter(Boolean);
+}
+function qualityNumber(record, fallback, ...keys) {
+    const value = qualityValue(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 fallback;
+}
+function qualityOptionalNumber(record, ...keys) {
+    const value = qualityValue(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 escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+async function readBrowserContent(target, methodNames) {
+    const value = await invokeBrowserMethod(target, methodNames);
+    return String(value ?? "");
+}
+async function invokeBrowserMethod(target, methodNames, ...args) {
+    const record = qualityRecord(target);
+    for (const name of methodNames) {
+        const method = record[name];
+        if (typeof method === "function") {
+            return await method.apply(target, args);
+        }
+    }
+    throw new Error(`Browser object does not expose ${methodNames.join(" or ")}.`);
+}
+function invokeBrowserMethodSync(target, methodNames, ...args) {
+    const record = qualityRecord(target);
+    for (const name of methodNames) {
+        const method = record[name];
+        if (typeof method === "function") {
+            return method.apply(target, args);
+        }
+    }
+    throw new Error(`Browser object does not expose ${methodNames.join(" or ")}.`);
+}
+function normalizeWebVitalsSnapshot(url, snapshot) {
+    const source = qualityRecord(snapshot);
+    return {
+        url,
+        largestContentfulPaintMs: qualityNumber(source, 0, "largestContentfulPaintMs", "LargestContentfulPaintMs", "LCP", "lcp"),
+        interactionToNextPaintMs: qualityNumber(source, 0, "interactionToNextPaintMs", "InteractionToNextPaintMs", "INP", "inp"),
+        cumulativeLayoutShift: qualityNumber(source, 0, "cumulativeLayoutShift", "CumulativeLayoutShift", "CLS", "cls"),
+        firstContentfulPaintMs: qualityNumber(source, 0, "firstContentfulPaintMs", "FirstContentfulPaintMs", "FCP", "fcp"),
+        timeToFirstByteMs: qualityNumber(source, 0, "timeToFirstByteMs", "TimeToFirstByteMs", "TTFB", "ttfb")
+    };
+}
 function validateAbsoluteUrl(value, label) {
     if (typeof value !== "string" || !value.trim()) {
         throw new Error(`${label} must be provided.`);
@@ -1944,6 +2230,26 @@ export class LoadStrikeScenario {
     __loadStrikeInternalLicenseFeatures() {
         return [...this.internalLicenseFeatures];
     }
+    __loadStrikeScenarioSourceAnalysis() {
+        const source = this.runHandler.toString();
+        const lines = source
+            .split(/\r?\n/)
+            .map((line) => line.trim())
+            .filter((line) => line.length > 0 && !line.startsWith("//"));
+        const lineCount = Math.max(lines.length, 1);
+        return {
+            ScenarioName: this.name,
+            Language: "TypeScript/JavaScript",
+            AnalyzerVersion: "function-source-v1",
+            ScenarioBlockLineCount: lineCount,
+            LocalMethodLineCount: 0,
+            TotalCountedLineCount: lineCount,
+            IgnoredExternalCallCount: 0,
+            Warnings: [
+                "Function-source analysis counts the scenario handler source available at runtime; imported library implementation lines are ignored."
+            ]
+        };
+    }
     __loadStrikeWithInternalLicenseFeatures(...features) {
         const merged = Array.from(new Set([...this.internalLicenseFeatures, ...normalizeStringArray(features)]));
         return new LoadStrikeScenario(this.name, this.runHandler, this.initHandler, this.cleanHandler, this.loadSimulations, this.thresholds, this.trackingConfiguration, this.maxFailCount, this.withoutWarmUpValue, this.warmUpDurationSeconds, this.weight, this.restartIterationOnFail, merged);
@@ -8037,7 +8343,8 @@ function buildLicenseValidationPayload(options, scenarios) {
             Weight: scenario.getWeight(),
             LoadSimulations: [...scenario.getSimulations()],
             Thresholds: [...scenario.getThresholds()],
-            Tracking: scenario.getTrackingConfiguration() ?? {}
+            Tracking: scenario.getTrackingConfiguration() ?? {},
+            ScenarioSourceAnalysis: scenario.__loadStrikeScenarioSourceAnalysis()
         };
         const internalLicenseFeatures = scenario.__loadStrikeInternalLicenseFeatures();
         if (internalLicenseFeatures.length > 0) {

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);