Expanded Built-In Sinks

package main

import loadstrike "loadstrike.com/sdk/go"

func main() {
    scenario := loadstrike.EmptyScenario("orders-expanded-sinks").
        WithLoadSimulations(loadstrike.LoadStrikeSimulation.Inject(20, loadstrike.DurationFromSeconds(1), loadstrike.DurationFromSeconds(120)))

    context := loadstrike.RegisterScenarios(scenario).
        WithReportingInterval(loadstrike.DurationFromSeconds(5)).
        WithReportingSinks(
            loadstrike.PrometheusRemoteWriteReportingSink{
                Options: loadstrike.HTTPReportingSinkOptions{EndpointURL: "https://prometheus.example.com/api/v1/write"},
            },
            loadstrike.JsonlFileReportingSink{
                Options: loadstrike.JsonlFileReportingSinkOptions{Path: "./reports/loadstrike-events.jsonl"},
            },
            // Use GenericWebhook only when the receiver accepts generic LoadStrike JSON.
            loadstrike.GenericWebhookReportingSink{
                Options: loadstrike.HTTPReportingSinkOptions{EndpointURL: "https://loadstrike-gateway.example.com/ingest"},
            },
        ).
        WithRunnerKey("rkl_your_enterprise_runner_key")

    _ = context
}

import java.io.IOException;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.file.Path;
import java.time.Duration;

import com.loadstrike.runtime.LoadStrikeRuntime.LoadStrikeRunner;
import com.loadstrike.runtime.LoadStrikeRuntime.LoadStrikeScenario;
import com.loadstrike.runtime.LoadStrikeRuntime.LoadStrikeSimulation;
import com.loadstrike.runtime.LoadStrikeSinks.JsonlFileReportingSink;
import com.loadstrike.runtime.LoadStrikeSinks.PrometheusOptions;
import com.loadstrike.runtime.LoadStrikeSinks.PrometheusRemoteWriteReportingSink;
import com.loadstrike.runtime.LoadStrikeSinks.ProtocolPublishException;
import com.loadstrike.runtime.LoadStrikeSinks.ProtocolPublisher;

var scenario = LoadStrikeScenario.empty("orders-expanded-sinks")
    .withLoadSimulations(LoadStrikeSimulation.inject(20, 1d, 120d));

var http = HttpClient.newBuilder()
    .connectTimeout(Duration.ofSeconds(10))
    .build();

// Migration: direct metric sinks now require options plus a publisher.
ProtocolPublisher publisher = (target, headers, body) -> {
  var request = HttpRequest.newBuilder(URI.create(target))
      .timeout(Duration.ofSeconds(30))
      .POST(HttpRequest.BodyPublishers.ofByteArray(body));
  headers.forEach(request::header);
  try {
    var response = http.send(request.build(), HttpResponse.BodyHandlers.discarding());
    if (response.statusCode() < 200 || response.statusCode() >= 300) {
      throw new ProtocolPublishException(
          response.statusCode(), "Reporting destination rejected the request.");
    }
  } catch (InterruptedException error) {
    Thread.currentThread().interrupt();
    throw new IllegalStateException("Reporting publish was interrupted.", error);
  } catch (IOException error) {
    throw new IllegalStateException("Reporting publish failed.", error);
  }
};

var prometheus = new PrometheusRemoteWriteReportingSink(
    new PrometheusOptions(
        "https://prometheus.example.com/api/v1/write",
        System.getenv("PROMETHEUS_BEARER_TOKEN")),
    publisher);

var jsonl = new JsonlFileReportingSink(
    Path.of("./reports/loadstrike-events.jsonl"));

LoadStrikeRunner.registerScenarios(scenario)
    .withReportingInterval(5d)
    .withReportingSinks(prometheus, jsonl)
    .withRunnerKey("rkl_your_enterprise_runner_key")
    .run();

import os

from loadstrike_sdk import (
    GenericWebhookReportingSink,
    JsonlFileReportingSink,
    LoadStrikeRunner,
    LoadStrikeScenario,
    LoadStrikeSimulation,
    PrometheusRemoteWriteReportingSink,
)

scenario = (
    LoadStrikeScenario.empty("orders-expanded-sinks")
    .with_load_simulations(LoadStrikeSimulation.inject(20, 1, 120))
)

jsonl = JsonlFileReportingSink(file_path="./reports/loadstrike-events.jsonl")
prometheus = PrometheusRemoteWriteReportingSink(
    base_url="https://prometheus.example.com",
    bearer_token=os.environ.get("PROMETHEUS_BEARER_TOKEN", ""),
)
# Migration from an old generic metrics URL: this body remains LoadStrike JSON.
webhook = GenericWebhookReportingSink(
    base_url="https://loadstrike-gateway.example.com",
    endpoint_path="/ingest",
    headers={"Authorization": "LoadStrike gateway-secret"},
)

LoadStrikeRunner.register_scenarios(scenario) \
    .with_reporting_interval(5) \
    .with_reporting_sinks(prometheus, jsonl, webhook) \
    .with_runner_key("rkl_your_enterprise_runner_key") \
    .run()

import {
  GenericWebhookReportingSink,
  JsonlFileReportingSink,
  LoadStrikeRunner,
  LoadStrikeScenario,
  LoadStrikeSimulation,
  PrometheusRemoteWriteReportingSink
} from "@loadstrike/loadstrike-sdk";

const scenario = LoadStrikeScenario
  .empty("orders-expanded-sinks")
  .withLoadSimulations(LoadStrikeSimulation.inject(20, 1, 120));

const jsonl = new JsonlFileReportingSink({ FilePath: "./reports/loadstrike-events.jsonl" });
const prometheus = new PrometheusRemoteWriteReportingSink({
  BaseUrl: "https://prometheus.example.com",
  BearerToken: process.env.PROMETHEUS_BEARER_TOKEN
});
// Migration from an old generic metrics URL: this body remains LoadStrike JSON.
const webhook = new GenericWebhookReportingSink({
  BaseUrl: "https://loadstrike-gateway.example.com",
  EndpointPath: "/ingest",
  Headers: { Authorization: "LoadStrike gateway-secret" }
});

await LoadStrikeRunner
  .registerScenarios(scenario)
  .withReportingInterval(5)
  .withReportingSinks(prometheus, jsonl, webhook)
  .withRunnerKey("rkl_your_enterprise_runner_key")
  .run();

const {
  GenericWebhookReportingSink,
  JsonlFileReportingSink,
  LoadStrikeRunner,
  LoadStrikeScenario,
  LoadStrikeSimulation,
  PrometheusRemoteWriteReportingSink
} = require("@loadstrike/loadstrike-sdk");

(async () => {
  const scenario = LoadStrikeScenario
    .empty("orders-expanded-sinks")
    .withLoadSimulations(LoadStrikeSimulation.inject(20, 1, 120));

  const jsonl = new JsonlFileReportingSink({ FilePath: "./reports/loadstrike-events.jsonl" });
  const prometheus = new PrometheusRemoteWriteReportingSink({
    BaseUrl: "https://prometheus.example.com",
    BearerToken: process.env.PROMETHEUS_BEARER_TOKEN
  });
  // Migration from an old generic metrics URL: this body remains LoadStrike JSON.
  const webhook = new GenericWebhookReportingSink({
    BaseUrl: "https://loadstrike-gateway.example.com",
    EndpointPath: "/ingest",
    Headers: { Authorization: "LoadStrike gateway-secret" }
  });

  await LoadStrikeRunner
    .registerScenarios(scenario)
    .withReportingInterval(5)
    .withReportingSinks(prometheus, jsonl, webhook)
    .withRunnerKey("rkl_your_enterprise_runner_key")
    .run();
})();