Skip to content

Synthetic telemetry · open source

Synthetic telemetry generator for testing observability pipelines.

Sonda generates metrics and logs with realistic patterns from a single static binary. Use it to test your pipelines, alerts, and dashboards before they break in production.

Get started in 5 minutes Try it in your browser See it on GitHub

curl -fsSL https://raw.githubusercontent.com/davidban77/sonda/main/install.sh | sh

crates.io   CI   MSRV   License

Try it

A Sonda scenario is a YAML file with three parts: a generator that produces values, an encoder that formats them, and a sink that sends them to a destination. Two commands set one up: sonda new --template creates a starter file, and sonda run runs it.

sonda new --template -o hello.yaml
sonda run hello.yaml --duration 3s

sonda new --template -o hello.yaml
wrote hello.yaml
sonda run hello.yaml --duration 3s
example_metric 1 1777243958972
example_metric 1 1777243959978
example_metric 1 1777243960981
■ example_metric  completed in 3.0s | events 3 | bytes 90 | errors 0

Each line uses the Prometheus exposition format: metric_name value timestamp_ms. See the glossary for the full definition.

Edit hello.yaml to change the signal pattern. You can swap constant for sine, add labels, or point the sink at a real backend.

hello.yaml (edited)
version: 2
kind: runnable
defaults:
  rate: 2
  duration: 5s
  encoder:
    type: prometheus_text
  sink:
    type: stdout
  labels:
    host: web-01
scenarios:
  - id: cpu_usage
    signal_type: metrics
    name: cpu_usage
    generator:
      type: sine
      amplitude: 50.0
      offset: 50.0
      period_secs: 4
Output
cpu_usage{host="web-01"} 50 1777243958972
cpu_usage{host="web-01"} 85.35533905932738 1777243959525
cpu_usage{host="web-01"} 100 1777243959982
cpu_usage{host="web-01"} 85.35533905932738 1777243960481

Sonda includes a CLI (sonda) and an optional HTTP server (sonda-server). The CLI is enough for laptop and CI use. The server accepts scenarios over a REST API. The same scenario file runs from your laptop, from CI, or from sonda-server. For a guided walkthrough that pushes to Prometheus or Loki, see Getting Started.

No install required

The real Sonda engine runs in your browser, compiled to WebAssembly. Edit a scenario and watch the signal it produces — then run the same YAML unchanged with sonda run.

  • Scenario playground

    Edit scenario YAML and see the exact values Sonda will emit — every generator, operational alias, and encoder, with real compile errors.

  • Alert lab

    Set a threshold and a for: duration against a failure pattern and watch the alert go pending → firing → resolved, in sync with the signal.

What do you want to test?

Every one of these is a small YAML file. Pick the failure, not the framework.

Trigger, resolve, and debounce alerts with signals shaped like real failures.

generator:
  type: spike_event
  baseline: 120.0
  spike_height: 400.0
  spike_duration: 5s
  spike_interval: 30s

Alert testing →

Inject label churn on a schedule and watch what your TSDB does under it.

cardinality_spikes:
  - label: pod
    every: 60s
    for: 10s
    cardinality: 500
    strategy: random

Capacity planning →

Export a Grafana panel from a real outage and replay it at the original cadence.

generator:
  type: csv_replay
  file: incident-2026-05-18.csv
  timescale: 4.0   # replay 4x faster

Grafana exports →

Fill a demo dashboard with a believable fleet instead of one flat line.

generator: { type: steady, center: 45.0, noise: 3.0 }
dynamic_labels:
  - key: host
    strategy: counter
    prefix: web-
    cardinality: 12

Send to a real backend →

Why not a bash loop?

Honest answer: a bash loop piping to curl is fine for checking that the port is open. It stops being fine the moment the shape of the data matters — alert thresholds, rate() windows, cardinality limits, retention behavior.

bash + curl Avalanche flog Sonda
Realistic value shapes (sine, flap, leak) hand-rolled — — ✓
Correlated failures (after:, while:) — — — ✓
Replay real incidents from CSV — — — ✓
Metrics and logs, histograms, summaries scripted metrics only logs only ✓
Remote-write, OTLP, Kafka, Loki, InfluxDB LP curl-able only remote-write files/stdout ✓
Scheduled gaps, bursts, cardinality spikes — churn only — ✓
Single static binary n/a ✓ ✓ ✓

Avalanche is excellent at raw cardinality volume and flog at log throughput — if that's the whole job, use them. Sonda is for when the pipeline has to be tested against telemetry that behaves like production.

Why Sonda

  • Fast and self-contained

    A single 5 MB static binary. No runtime, no JVM, no Python. Starts in under 50 ms and runs anywhere a Linux container runs. The same binary works on your laptop, your CI runner, and as a Kubernetes Job.

  • Realistic signal patterns

    Metrics with sine, sawtooth, step, and spike value patterns. Logs with bursty distributions. Histograms with realistic latency tails. Match real production data on schema, cardinality, and failure modes. Not only on volume.

  • Supports your pipeline's protocols

    Encoders write formats like Prometheus text, InfluxDB line protocol, JSON, syslog, OTLP, and Prometheus remote-write. Sinks send data to stdout, files, TCP/UDP, HTTP, Kafka, Loki, and OTLP collectors. Pick an encoder and a sink. No extra setup needed per stack.

  • Scenarios as YAML files

    Scenarios are YAML files. Check them into git, review them in pull requests, and template them. Override any field with CLI flags or SONDA_* env vars. No need to fork the file.

Where to next

  • Get started in 5 minutes

    Install Sonda, stream your first metric, and send it to a real backend.

  • Write your own scenarios

    Organize runnable scenarios and composable packs in a catalog directory. Discover them with sonda list --catalog <dir> and run them with sonda run @name.

  • Test your alert rules

    Trigger, resolve, and validate alert rules with realistic metric patterns. Covers thresholds, correlation, cardinality, histograms, and recording rules.

  • Run as a server

    Run sonda-server as a long-lived HTTP control plane and submit scenarios over the REST API. Useful for CI and synthetic-monitoring fleets.

Part of the Modern Network Observability ecosystem