LoadStrike
Run Quick Start

Documentation / Realtime Reporting

Realtime Reporting

Realtime reporting streams LoadStrike data to external backends during the run and again when the run finishes.

What this page helps you do

What this page helps you do

Realtime reporting streams LoadStrike data to external backends during the run and again when the run finishes.

Who this is for

Teams exporting final run data and realtime metrics into supported observability backends.

Prerequisites

  • A run result or sink destination you want to wire into the wider observability stack

By the end

A sink-specific setup path that stays tied to the same LoadStrike report model.

Open realtime reporting hub Read report overview

Use this page when

Use this page when the local report is not the only destination and you need to wire realtime or final export into a supported sink.

Visual guide

Annotated report diagram showing summary, scenario views, and failure analysis.
The same run result powers summary reading, failure diagnosis, grouped correlation, and export flows.

Sample Report Data Rows

Scope    Scenario     Result Count RPS  LatencyP50Ms LatencyP80Ms LatencyP85Ms LatencyP90Ms LatencyP95Ms LatencyP99Ms
Scenario reports-demo OK     675   15.0 21.4         30.2         33.0         36.8         48.6         72.1

LatencyTable Scenario     Result Count LatencyP50Ms LatencyP95Ms
LatencyTable reports-demo OK     675   21.4         48.6
LatencyTable reports-demo FAIL   12    35.9         79.2

StatusCode Result Percent
200        OK     97.48
500        FAIL   2.52

FailedStatus Scope     Scenario     Step StatusCode Count Percent
FailedStatus Scenario  reports-demo      500       12    1.75

Reporting

Realtime reporting

Choose the built-in sink page that matches the backend your team already runs, or open Custom Reporting when you need to implement your own destination. Each tab opens a dedicated page with the settings, behavior, and lifecycle details for that reporting path.

Custom reporting Custom Reporting

Use custom reporting when you need a sink that is not built in and still want the normal LoadStrike sink lifecycle.

Open page
Built-in sink Datadog

Use the Datadog sink when your team already reads events and metrics in Datadog. This page explains what LoadStrike sends there and how to configure it.

Open page
Built-in sink InfluxDB

Use the InfluxDB sink when your team wants LoadStrike events and metrics stored in an Influx bucket. This page explains the data flow and the optional metrics split.

Open page
Built-in sink TimescaleDB

Use the TimescaleDB sink when you want LoadStrike reporting data in PostgreSQL-compatible tables with optional metrics splits.

Open page
Built-in sink Grafana Loki

Use the Grafana Loki sink when you want log-style LoadStrike events in Loki and projected metrics through a companion OTLP path.

Open page
Built-in sink Splunk HEC

Use the Splunk HEC sink when you want LoadStrike reporting events and projected metrics delivered through Splunk.

Open page
Built-in sink OTEL Collector

Use the OTEL Collector sink when the team already standardizes on OpenTelemetry collector pipelines. This page explains the OTLP/HTTP path that LoadStrike uses.

Open page

Guide

What Built-In Sinks Export

All built-in sinks publish LoadStrike reporting events plus metric projections. Final export also includes final metric snapshots, started and completed timestamps, report-file metadata, disabled sink names, sink error counts, and plugin-table rows such as failed-response and correlation summaries.

Built-In Or Custom

Use a built-in sink page when your team already runs Datadog, InfluxDB, TimescaleDB, Grafana Loki, Splunk HEC, or OTEL Collector. Open Custom Reporting when you need to implement your own destination but still want the same realtime and final sink lifecycle.

Configuration Model

Each built-in sink accepts an options object in code and can also bind missing values from LoadStrike:ReportingSinks:* infra-config sections. Realtime writes follow the configured reporting interval, and final export writes the run summary plus artifact metadata when the run completes.

Failure Behavior

Sink init, start, realtime export, and final export all use retry and backoff. If a sink continues to fail, LoadStrike logs the issue, disables that sink for the current run, and continues the main load execution instead of aborting the scenarios.

Plan Gate And Extensibility

Business and above include the built-in vendor sinks for InfluxDB, TimescaleDB, Grafana Loki, Datadog, Splunk HEC, and OTEL Collector and allow custom reporting sink implementations when a project-specific destination is required.

Realtime reporting setup

Start by registering the sink you want, set the reporting interval, and optionally load the sink settings from infra config.

If you run these examples locally, add a valid runner key before execution starts. Set it with WithRunnerKey("...") or the config key LoadStrike:RunnerKey.

HTML reports also include the top-right Light/Dark theme toggle. Light is the default report theme.

Realtime Reporting Setup

using LoadStrike;

var scenario = LoadStrikeScenario.Empty("orders-realtime-reporting")
    .WithLoadSimulations(
        LoadStrikeSimulation.Inject(rate: 20, interval: TimeSpan.FromSeconds(1), during: TimeSpan.FromMinutes(2))
    );

LoadStrikeRunner.RegisterScenarios(scenario)
    .WithReportingInterval(TimeSpan.FromSeconds(5))
    .LoadInfraConfig("./observability/loadstrike-datadog-reporting-sink.json")
    .WithReportingSinks(new DatadogReportingSink())
    .WithRunnerKey("rkl_your_local_runner_key")
    .Run();

Realtime reporting fields and lifecycle

WithReportingInterval

Controls how often realtime scenario statistics and projected metrics are emitted during the run.

WithReportingSinks

Registers one or more sink instances in code.

LoadInfraConfig

Loads sink configuration from a separate infra-config file so secrets and backend-specific settings stay outside the test code.

SinkName / sinkName / sink_name

Every sink uses a stable sink identifier so disabledSinks and sinkErrors can point back to the correct destination.

Failure handling

Sink init, start, realtime export, and final export use retry and backoff. Persistent sink failure disables only that sink for the run instead of aborting the workload.

Final export

Every built-in sink also receives final metric snapshots, started/completed timestamps, report-file metadata, disabled sink names, sink errors, and plugin-table rows when the run completes.

Export ordering

Realtime callbacks happen during execution. Final export receives the completed LoadStrikeRunResult before Stop and Dispose run, so threshold results, plugin tables, and report file metadata are already available.

Dispose / dispose()

Runs after Stop as the final sink cleanup hook. Use it to close files, sockets, HTTP clients, or other owned resources. Dispose failures are recorded in sinkErrors with phase=dispose and do not abort shutdown.

{
  "LoadStrike": {
    "ReportingIntervalMs": 5000,
    "ReportingSinks": {
      "Datadog": {
        "BaseUrl": "https://api.datadoghq.com",
        "ApiKey": "dd-api-key",
        "ApplicationKey": "dd-app-key"
      },
      "InfluxDb": {
        "BaseUrl": "https://influx.example.com",
        "Bucket": "loadstrike-runs",
        "MeasurementName": "loadstrike_events"
      }
    }
  }
}

Shared Downloads

Use these shared assets when you need the combined guide or the common Grafana dashboard-provider file.

Observability asset guide

A single guide that brings together the built-in sink templates and Grafana starter assets.

Download file

Dashboard provider YAML

The shared Grafana dashboard-provider file used by the InfluxDB, TimescaleDB, and Grafana Loki starter dashboards.

Download file
Related

Related category and article pages

Use these links to move from the reference page into the broader workload, integration, or article context.