Load Simulation

package main

import loadstrike "loadstrike.com/sdk/go"

func main() {
    scenario := loadstrike.CreateScenario("load-shapes", func(loadstrike.LoadStrikeScenarioContext) loadstrike.LoadStrikeReply {
        return loadstrike.LoadStrikeResponse.Ok("200")
    }).WithLoadSimulations(
        loadstrike.LoadStrikeSimulation.Inject(10, loadstrike.DurationFromSeconds(1), loadstrike.DurationFromSeconds(20)),
        loadstrike.LoadStrikeSimulation.InjectRandom(5, 15, loadstrike.DurationFromSeconds(1), loadstrike.DurationFromSeconds(20)),
        loadstrike.LoadStrikeSimulation.RampingInject(20, loadstrike.DurationFromSeconds(1), loadstrike.DurationFromSeconds(20)),
        loadstrike.LoadStrikeSimulation.KeepConstant(5, loadstrike.DurationFromSeconds(20)),
        loadstrike.LoadStrikeSimulation.Pause(loadstrike.DurationFromSeconds(3)),
    )

    loadstrike.Create().
        AddScenario(scenario).
        UseLoadEngineV2().
        WithMaxInFlight(5000).
        WithRunnerKey("rkl_your_local_runner_key").
        Run()
}

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

import com.loadstrike.runtime.LoadStrikeRuntime.LoadStrikeResponse;
import com.loadstrike.runtime.LoadStrikeRuntime.LoadStrikeRunner;
import com.loadstrike.runtime.LoadStrikeRuntime.LoadStrikeScenario;
import com.loadstrike.runtime.LoadStrikeRuntime.LoadStrikeSimulation;
import com.loadstrike.runtime.LoadStrikeRuntime.LoadStrikeStep;

var client = HttpClient.newHttpClient();

var scenario = LoadStrikeScenario.create("submit-orders", context -> {
      var step = LoadStrikeStep.run("POST /orders", context, () -> {
        String body = "{\"orderId\":\"ord-" + context.invocationNumber + "\",\"amount\":49.95}";
        var request = HttpRequest.newBuilder(URI.create("https://api.example.com/orders"))
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(body))
            .build();
        var response = client.sendAsync(request, HttpResponse.BodyHandlers.ofString()).join();
        return response.statusCode() < 400
            ? LoadStrikeResponse.ok(Integer.toString(response.statusCode()))
            : LoadStrikeResponse.fail(Integer.toString(response.statusCode()));
      });

      return step.asReply();
    })
    .withLoadSimulations(
        LoadStrikeSimulation.inject(5, 1d, 20d),
        LoadStrikeSimulation.rampingInject(20, 1d, 20d),
        LoadStrikeSimulation.keepConstant(8, 20d)
    );

LoadStrikeRunner
    .registerScenarios(scenario)
    .useLoadEngineV2()
    .withMaxInFlight(5000)
    .withRunnerKey("rkl_your_local_runner_key")
    .run();

import requests

from loadstrike_sdk import (
    LoadStrikeResponse,
    LoadStrikeRunner,
    LoadStrikeScenario,
    LoadStrikeSimulation,
    LoadStrikeStep,
)

def submit_orders(context):
    step = LoadStrikeStep.run(
        "POST /orders",
        context,
        lambda: (
            lambda response: LoadStrikeResponse.ok(str(response.status_code))
            if response.ok
            else LoadStrikeResponse.fail(str(response.status_code))
        )(
            requests.post(
                "https://api.example.com/orders",
                json={"orderId": f"ord-{context.invocation_number}", "amount": 49.95},
                timeout=15,
            )
        ),
    )
    return step.as_reply()

scenario = (
    LoadStrikeScenario.create("submit-orders", submit_orders)
    .with_load_simulations(
        LoadStrikeSimulation.inject(5, 1, 20),
        LoadStrikeSimulation.ramping_inject(20, 1, 20),
        LoadStrikeSimulation.keep_constant(8, 20),
    )
)

LoadStrikeRunner.register_scenarios(scenario) \
    .use_load_engine_v2() \
    .with_max_in_flight(5000) \
    .with_runner_key("rkl_your_local_runner_key") \
    .run()

import {
  LoadStrikeResponse,
  LoadStrikeRunner,
  LoadStrikeScenario,
  LoadStrikeSimulation,
  LoadStrikeStep
} from "@loadstrike/loadstrike-sdk";

const scenario = LoadStrikeScenario.create("submit-orders", async (context) => {
  const step = await LoadStrikeStep.run("POST /orders", context, async () => {
    const response = await fetch("https://api.example.com/orders", {
      method: "POST",
      headers: { "content-type": "application/json" },
      body: JSON.stringify({
        orderId: `ord-${context.invocationNumber}`,
        amount: 49.95
      })
    });

    return response.ok
      ? LoadStrikeResponse.ok(String(response.status))
      : LoadStrikeResponse.fail(String(response.status));
  });

  return step.asReply();
}).withLoadSimulations(
  LoadStrikeSimulation.inject(5, 1, 20),
  LoadStrikeSimulation.rampingInject(20, 1, 20),
  LoadStrikeSimulation.keepConstant(8, 20)
);

await LoadStrikeRunner
  .registerScenarios(scenario)
  .useLoadEngineV2()
  .withMaxInFlight(5000)
  .withRunnerKey("rkl_your_local_runner_key")
  .run();

const {
  LoadStrikeResponse,
  LoadStrikeRunner,
  LoadStrikeScenario,
  LoadStrikeSimulation,
  LoadStrikeStep
} = require("@loadstrike/loadstrike-sdk");

(async () => {
  const scenario = LoadStrikeScenario.create("submit-orders", async (context) => {
    const step = await LoadStrikeStep.run("POST /orders", context, async () => {
      const response = await fetch("https://api.example.com/orders", {
        method: "POST",
        headers: { "content-type": "application/json" },
        body: JSON.stringify({
          orderId: `ord-${context.invocationNumber}`,
          amount: 49.95
        })
      });

      return response.ok
        ? LoadStrikeResponse.ok(String(response.status))
        : LoadStrikeResponse.fail(String(response.status));
    });

    return step.asReply();
  }).withLoadSimulations(
    LoadStrikeSimulation.inject(5, 1, 20),
    LoadStrikeSimulation.rampingInject(20, 1, 20),
    LoadStrikeSimulation.keepConstant(8, 20)
  );

  await LoadStrikeRunner
    .registerScenarios(scenario)
    .useLoadEngineV2()
    .withMaxInFlight(5000)
    .withRunnerKey("rkl_your_local_runner_key")
    .run();
})();