Custom Reporting

package main

import (
    "fmt"

    loadstrike "loadstrike.com/sdk/go"
)

type internalOpsSink struct {
    loadstrike.LoadStrikeReportingSinkBase
}

func (internalOpsSink) SinkName() string { return "internal-ops" }

func (internalOpsSink) SaveIterationBatch(batch loadstrike.LoadStrikeIterationObservationBatch) loadstrike.LoadStrikeTask {
    fmt.Printf("Raw attempts: %d\n", len(batch.Observations))
    return loadstrike.CompletedTask()
}

func (internalOpsSink) CompleteIterationStream(completion loadstrike.LoadStrikeIterationStreamCompletion) loadstrike.LoadStrikeTask {
    fmt.Printf("Delivered: %s; dropped: %s\n", completion.DeliveredCount64, completion.DroppedBufferCount64)
    return loadstrike.CompletedTask()
}

func main() {
    scenario := loadstrike.CreateScenario("custom-reporting", func(loadstrike.LoadStrikeScenarioContext) loadstrike.LoadStrikeReply {
        return loadstrike.LoadStrikeResponse.Ok("200")
    }).WithLoadSimulations(
        loadstrike.LoadStrikeSimulation.Inject(10, loadstrike.DurationFromSeconds(1), loadstrike.DurationFromSeconds(20)),
    )

    loadstrike.RegisterScenarios(scenario).
        WithReportingInterval(loadstrike.DurationFromSeconds(5)).
        WithReportingSinks(internalOpsSink{}).
        WithRunnerKey("rkl_your_enterprise_runner_key").
        Run()
}

import com.loadstrike.runtime.LoadStrikeRuntime.LoadStrikeRunner;
import com.loadstrike.runtime.LoadStrikeRuntime.LoadStrikeBaseContext;
import com.loadstrike.runtime.LoadStrikeRuntime.LoadStrikeMetricStats;
import com.loadstrike.runtime.LoadStrikeRuntime.LoadStrikeReportingSink;
import com.loadstrike.runtime.LoadStrikeRuntime.LoadStrikeResponse;
import com.loadstrike.runtime.LoadStrikeRuntime.LoadStrikeRunResult;
import com.loadstrike.runtime.LoadStrikeRuntime.LoadStrikeScenario;
import com.loadstrike.runtime.LoadStrikeRuntime.LoadStrikeScenarioStats;
import com.loadstrike.runtime.LoadStrikeRuntime.LoadStrikeSessionStartInfo;
import com.loadstrike.runtime.LoadStrikeRuntime.LoadStrikeSimulation;
import com.loadstrike.runtime.LoadStrikeIterationBatchSink;
import com.loadstrike.runtime.LoadStrikeIterationObservations.LoadStrikeIterationObservationBatch;
import com.loadstrike.runtime.LoadStrikeIterationObservations.LoadStrikeIterationObservationStreamCompletion;
import java.util.Map;
import java.util.concurrent.CompletableFuture;

final class InternalOpsSink implements LoadStrikeReportingSink, LoadStrikeIterationBatchSink {
    @Override
    public String sinkName() {
        return "internal-ops";
    }

    @Override
    public void init(LoadStrikeBaseContext context, Map<String, Object> infraConfig) {
    }

    @Override
    public void start(LoadStrikeSessionStartInfo sessionInfo) {
    }

    @Override
    public void saveRealtimeStats(LoadStrikeScenarioStats[] scenarioStats) {
        for (var scenario : scenarioStats) {
            System.out.println(scenario.scenarioName + ": " + scenario.allRequestCount);
        }
    }

    @Override
    public void saveRealtimeMetrics(LoadStrikeMetricStats metrics) {
    }

    @Override
    public void saveIterationBatch(LoadStrikeIterationObservationBatch batch) {
        System.out.println("Raw attempts: " + batch.observations().size());
    }

    @Override
    public void completeIterationObservationStream(LoadStrikeIterationObservationStreamCompletion completion) {
        System.out.println("Delivered: " + completion.deliveredCount64()
            + "; dropped: " + completion.droppedBufferCount64());
    }

    @Override
    public void saveRunResult(LoadStrikeRunResult result) {
        System.out.println("Final requests: " + result.allRequestCount);
    }

    @Override
    public void stop() {
    }

    @Override
    public void dispose() {
    }
}

var scenario = LoadStrikeScenario
    .createAsync("submit-orders", ignoredContext -> CompletableFuture.supplyAsync(() -> LoadStrikeResponse.ok("200")))
    .withLoadSimulations(LoadStrikeSimulation.inject(10, 1d, 20d));

LoadStrikeRunner.registerScenarios(scenario)
    .withReportingInterval(5)
    .withReportingSinks(new InternalOpsSink())
    .withRunnerKey("rkl_your_local_runner_key")
    .run();

import asyncio
from loadstrike_sdk import LoadStrikeResponse, LoadStrikeRunner, LoadStrikeScenario, LoadStrikeSimulation


class InternalOpsSink:
    @property
    def sink_name(self) -> str:
        return "internal-ops"

    def init(self, context, infra_config) -> None:
        pass

    def start(self, session) -> None:
        pass

    def save_realtime_stats(self, scenario_stats) -> None:
        for scenario in scenario_stats:
            print(f"{scenario['scenarioName']}: {scenario['allRequestCount']}")

    def save_realtime_metrics(self, metrics) -> None:
        pass

    def save_iteration_batch(self, batch) -> None:
        wire_batch = batch.to_dict() if hasattr(batch, "to_dict") else dict(batch)
        print(f"Raw attempts: {len(wire_batch['observations'])}")

    def complete_iteration_observation_stream(self, completion) -> None:
        wire_completion = completion.to_dict() if hasattr(completion, "to_dict") else dict(completion)
        print(
            f"Delivered: {wire_completion['deliveredCount64']}; "
            f"dropped: {wire_completion['droppedBufferCount64']}"
        )

    def save_run_result(self, result) -> None:
        print(f"Final requests: {result.all_request_count}")

    def stop(self) -> None:
        pass

    def dispose(self) -> None:
        pass


async def run_step(_):
    await asyncio.sleep(0.025)
    return LoadStrikeResponse.ok("200")


scenario = (
    LoadStrikeScenario.create_async("submit-orders", run_step)
    .with_load_simulations(LoadStrikeSimulation.inject(10, 1, 20))
)

LoadStrikeRunner.register_scenarios(scenario) \
    .with_reporting_interval(5) \
    .with_reporting_sinks(InternalOpsSink()) \
    .with_runner_key("rkl_your_local_runner_key") \
    .run()

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

const sink: ILoadStrikeReportingSink = {
  sinkName: "internal-ops",
  saveRealtimeStats: async (scenarioStats) => {
    for (const scenario of scenarioStats) {
      console.log(`${scenario.scenarioName}: ${scenario.allRequestCount}`);
    }
  },
  saveRealtimeMetrics: async () => {},
  saveIterationBatch: async (batch) => {
    console.log(`Raw attempts: ${batch.observations.length}`);
  },
  completeIterationObservationStream: async (completion) => {
    console.log(`Delivered: ${completion.deliveredCount64}; dropped: ${completion.droppedBufferCount64}`);
  },
  saveRunResult: async (result) => {
    console.log(`Final requests: ${result.allRequestCount}`);
  },
  stop: async () => {},
  dispose: async () => {}
};

const scenario = LoadStrikeScenario
  .createAsync("submit-orders", async () => {
    await new Promise((resolve) => setTimeout(resolve, 25));
    return LoadStrikeResponse.ok("200");
  })
  .withLoadSimulations(LoadStrikeSimulation.inject(10, 1, 20));

await LoadStrikeRunner
  .registerScenarios(scenario)
  .withReportingInterval(5)
  .withReportingSinks(sink)
  .withRunnerKey("rkl_your_local_runner_key")
  .run();

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

const sink = {
  sinkName: "internal-ops",
  async saveRealtimeStats(scenarioStats) {
    for (const scenario of scenarioStats) {
      console.log(`${scenario.scenarioName}: ${scenario.allRequestCount}`);
    }
  },
  async saveRealtimeMetrics() {},
  async saveIterationBatch(batch) {
    console.log(`Raw attempts: ${batch.observations.length}`);
  },
  async completeIterationObservationStream(completion) {
    console.log(`Delivered: ${completion.deliveredCount64}; dropped: ${completion.droppedBufferCount64}`);
  },
  async saveRunResult(result) {
    console.log(`Final requests: ${result.allRequestCount}`);
  },
  async stop() {},
  async dispose() {}
};

(async () => {
  const scenario = LoadStrikeScenario
    .createAsync("submit-orders", async () => {
      await new Promise((resolve) => setTimeout(resolve, 25));
      return LoadStrikeResponse.ok("200");
    })
    .withLoadSimulations(LoadStrikeSimulation.inject(10, 1, 20));

  await LoadStrikeRunner
    .registerScenarios(scenario)
    .withReportingInterval(5)
    .withReportingSinks(sink)
    .withRunnerKey("rkl_your_local_runner_key")
    .run();
})();