TimescaleDB Documentation

Matching docs

Search across docs titles, summaries, groups, and section headings.

Use Up and Down Arrow to move through results, then press Enter to open the active page.

What this page helps you do

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

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.

Guide

When To Use TimescaleDB

Choose TimescaleDB when the platform standardizes on PostgreSQL-compatible storage but still wants queryable reporting-event rows and a dedicated projected-metrics table.

What LoadStrike Sends

TimescaleDbReportingSink writes reporting events into the configured table and can split projected metrics into a separate MetricsTableName. When available, the sink can also prepare hypertables for time-series-friendly storage.

Configuration Surface

Configure the sink in code or through LoadStrike:ReportingSinks:TimescaleDb. Common options include ConnectionString, Schema, TableName, MetricsTableName, CreateSchemaIfMissing, EnableHypertableIfAvailable, and StaticTags.

Starter Assets

LoadStrike publishes a TimescaleDB datasource YAML, the shared Grafana dashboard-provider YAML, and a TimescaleDB overview dashboard JSON file.

TimescaleDB realtime reporting

Use TimescaleDbReportingSink when you want PostgreSQL-compatible storage for events and projected metrics.

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.

TimescaleDB Sink

using LoadStrike;

var timescaleSink = new TimescaleDbReportingSink(new TimescaleDbReportingSinkOptions
{
    ConnectionString = "Host=db.example.com;Port=5432;Database=loadstrike;Username=postgres;Password=postgres",
    Schema = "observability",
    TableName = "loadstrike_reporting_events",
    MetricsTableName = "loadstrike_reporting_metrics",
    CreateSchemaIfMissing = true,
    EnableHypertableIfAvailable = true
});

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

package main

import loadstrike "loadstrike.com/sdk/go"

var timescaleSink = loadstrike.TimescaleDbReportingSink{
    Options: loadstrike.TimescaleDbReportingSinkOptions{
        ConnectionString:          "Host=127.0.0.1;Port=5432;Database=loadstrike;Username=postgres;Password=postgres",
        Schema:                    "public",
        TableName:                 "loadstrike_results",
        CreateSchemaIfMissing:     true,
        EnableHypertableIfAvailable: true,
    },
}

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

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

var options = new LoadStrikeSinks.TimescaleDbSinkOptions();
options.connectionString = "Host=db.example.com;Port=5432;Database=loadstrike;Username=postgres;Password=postgres";
options.schema = "observability";
options.tableName = "loadstrike_reporting_events";
options.metricsTableName = "loadstrike_reporting_metrics";
options.createSchemaIfMissing = true;
options.enableHypertableIfAvailable = true;

var sink = new LoadStrikeSinks.TimescaleDbReportingSink(options);

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

from loadstrike_sdk import LoadStrikeRunner, LoadStrikeScenario, LoadStrikeSimulation, TimescaleDbReportingSink

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

sink = TimescaleDbReportingSink(
    connection_string="Host=db.example.com;Port=5432;Database=loadstrike;Username=postgres;Password=postgres",
    schema="observability",
    table_name="loadstrike_reporting_events",
    metrics_table_name="loadstrike_reporting_metrics",
    create_schema_if_missing=True,
    enable_hypertable_if_available=True,
)

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

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

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

const sink = new TimescaleDbReportingSink(new TimescaleDbReportingSinkOptions({
  ConnectionString: "Host=db.example.com;Port=5432;Database=loadstrike;Username=postgres;Password=postgres",
  Schema: "observability",
  TableName: "loadstrike_reporting_events",
  MetricsTableName: "loadstrike_reporting_metrics",
  CreateSchemaIfMissing: true,
  EnableHypertableIfAvailable: true
}));

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

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

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

  const sink = new TimescaleDbReportingSink(new TimescaleDbReportingSinkOptions({
    ConnectionString: "Host=db.example.com;Port=5432;Database=loadstrike;Username=postgres;Password=postgres",
    Schema: "observability",
    TableName: "loadstrike_reporting_events",
    MetricsTableName: "loadstrike_reporting_metrics",
    CreateSchemaIfMissing: true,
    EnableHypertableIfAvailable: true
  }));

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

TimescaleDbReportingSinkOptions fields

ConfigurationSectionPath

Defaults to LoadStrike:ReportingSinks:TimescaleDb when binding from infra config.

ConnectionString

Required PostgreSQL or TimescaleDB connection string.

Schema

Target schema. Defaults to public and must be a valid SQL identifier.

TableName

Reporting-event table name. Must be a valid SQL identifier.

MetricsTableName

Projected-metrics table name. Must be a valid SQL identifier.

CreateSchemaIfMissing

Creates the target schema when it does not exist.

EnableHypertableIfAvailable

Attempts Timescale hypertable setup when the backend supports it.

StaticTags

Tags stored alongside exported rows and metric points.

{
  "LoadStrike": {
    "ReportingSinks": {
      "TimescaleDb": {
        "ConnectionString": "Host=db.example.com;Port=5432;Database=loadstrike;Username=postgres;Password=postgres",
        "Schema": "observability",
        "TableName": "loadstrike_reporting_events",
        "MetricsTableName": "loadstrike_reporting_metrics"
      }
    }
  }
}

Downloads and starter assets

These downloads cover the public TimescaleDB workflow that LoadStrike documents today.

Timescale datasource YAML

A Grafana datasource definition for a TimescaleDB-backed LoadStrike dashboard setup.

Download file

Dashboard provider YAML

The shared Grafana dashboard-provider file used by the published starter dashboards.

Download file

Timescale dashboard JSON

A starter dashboard already wired for the TimescaleDB sink shape documented on this page.

Download file

Matching docs

What this page helps you do

What this page helps you do

Who this is for

Prerequisites

By the end

Use this page when

Visual guide

Sample Report Data Rows

Realtime reporting

Guide

When To Use TimescaleDB

What LoadStrike Sends

Configuration Surface

Starter Assets

TimescaleDB realtime reporting

TimescaleDB Sink

TimescaleDbReportingSinkOptions fields

Downloads and starter assets

Timescale datasource YAML

Dashboard provider YAML

Timescale dashboard JSON

Related category and article pages

Datadog integration

OTEL Collector integration

Benchmark methodology