Licensing And Runtime Access

Understand runner-key validation and runtime access rules for the SDKs.

Runtime Requirement

LoadStrike requires a runner key for execution. If no runner key is provided, run start is blocked.

Online Validation

Before each run, the SDK validates the runner key. If validation cannot complete, run start is blocked.

Feature Availability

The active runner key determines which transports, clustering options, reporting sinks, and extensions are available for the run.

Config Surface

Set the runner key with WithRunnerKey(...) or LoadStrike:RunnerKey. Host classification is automatic, so there is no RunnerEnvironment setting to keep in sync.

Environment Rules

LoadStrike classifies laptops, desktops, and mobile devices as local, and CI, Kubernetes, and server hosts as remote. Remote environments require a remote-capable runner key.

Runtime Checks

Before the run starts, LoadStrike checks configured agents, targeted scenarios, reporting sinks, worker plugins, and timeout settings against the active runtime limits.

Registered Device Limits

Device-limited plans control how many machines can be associated with local execution. If your allowance changes, revalidation may require the active device list to be refreshed.

Run Behavior On Expiry

Runner keys are validated at run start. If the underlying license expires while a run is active, the current run is allowed to finish and the next run is blocked until validation succeeds again.

Feature Usage Samples

How to use snippets for Licensing And Runtime Access.

Switch between C#, Java, Python, TypeScript, and JavaScript to see the native SDK shape for this sample.

Licensing note: every runnable sample requires a valid runner key via WithRunnerKey("...") or config key LoadStrike:RunnerKey.

Runtime License Validation

var scenario = LoadStrikeScenario.Empty("licensed-orders")
    .WithLoadSimulations(LoadStrikeSimulation.KeepConstant(1, TimeSpan.FromSeconds(20)));

LoadStrikeRunner.RegisterScenarios(scenario)
    .WithRunnerKey("rkl_your_local_runner_key")
    .Run();

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

var scenario = LoadStrikeScenario.empty("licensed-orders")
    .withLoadSimulations(LoadStrikeSimulation.keepConstant(1, 20d));

LoadStrikeRunner.registerScenarios(scenario)
    .withRunnerKey("rkl_your_local_runner_key")
    .run();

from loadstrike_sdk import (
    LoadStrikeRunner,
    LoadStrikeScenario,
    LoadStrikeSimulation,
)

scenario = (
    LoadStrikeScenario.empty("licensed-orders")
    .with_load_simulations(LoadStrikeSimulation.keep_constant(1, 20))
)

LoadStrikeRunner.register_scenarios(scenario) \
    .with_runner_key("rkl_your_local_runner_key") \
    .run()

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

const scenario = LoadStrikeScenario
  .empty("licensed-orders")
  .withLoadSimulations(LoadStrikeSimulation.keepConstant(1, 20));

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

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

const scenario = LoadStrikeScenario
  .empty("licensed-orders")
  .withLoadSimulations(LoadStrikeSimulation.keepConstant(1, 20));

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

Library Configuration Surface

WithRunnerKey(...)

Provide the runner key required before any runnable workload can start.

Automatic environment detection

The SDK detects local vs remote execution automatically, so you do not need a separate RunnerEnvironment setting.

WithSessionId / WithTestSuite / WithTestName

Optional metadata values used for reports, sink tags, and run identification.

LoadStrike:RunnerKey

Appsettings key for supplying the runner key from configuration.

Remote-capable access

CI, Kubernetes, server infrastructure, and other non-local hosts need a remote-capable runner key.

Validation happens before run start, and available runtime features can affect devices, CI or distributed execution, sinks, plugins, clustering, and timeout ceilings.