TestData data source on Grafana Labs

Configure the TestData data source

Tue, 14 Apr 2026 14:59:56 +0000

Configure the TestData data source

This document explains how to configure the TestData data source. TestData requires no external connection or authentication, so configuration is minimal.

For general information on managing data sources, refer to Data source management.

Before you begin

You must have the Organization administrator role to add and configure data sources.

Add the data source

To add the TestData data source:

Click Connections in the left-side menu.
Click Add new connection.
Type TestData in the search bar.
Select TestData.
Click Add new data source.

Grafana takes you to the Settings tab.

Configuration options

TestData doesn’t require any settings beyond the standard options common to all data sources.

Setting	Description
Name	Sets the name you use to refer to the data source in panels and queries.
Default	Defines whether this data source is pre-selected for new panels.

Verify the connection

Click Save & test to verify the data source. A successful test displays the message:

Data source is working

If the test fails, refer to Troubleshoot TestData for common issues and solutions.

Provision the data source

You can define and configure the data source in YAML files as part of Grafana’s provisioning system. For more information about provisioning, refer to Provisioning data sources.

TestData doesn’t require any jsonData or secureJsonData fields.

YAML example

apiVersion: 1

datasources:
  - name: TestData
    type: grafana-testdata-datasource
    access: proxy

Provision with Terraform

To provision the data source with Terraform, use the grafana_data_source resource:

resource "grafana_data_source" "testdata" {
  name = "TestData"
  type = "grafana-testdata-datasource"
}

For all available configuration options, refer to the Grafana provider data source resource documentation.

Next steps

After configuring your TestData data source, you can:

Write queries using the 30 available scenarios to generate simulated data.
Use template variables to create dynamic, reusable dashboards.
Set up alerting to prototype and test alert rules with simulated data.
Troubleshoot issues if you encounter problems with your data source.

TestData query editor

Tue, 14 Apr 2026 14:59:56 +0000

TestData query editor

Instead of a traditional query language, the TestData data source uses scenarios to generate simulated data. Each scenario produces a different type of data suited for testing specific visualizations, behaviors, or edge cases. TestData includes 30 scenarios covering time series, logs, traces, graphs, streaming, and error simulation.

Use scenarios to:

Prototype dashboards without connecting to a real data source.
Reproduce bugs with controlled, deterministic data that other developers can replicate.
Test panel behavior with edge cases like empty results, timestamps outside the visible range, or mixed data and errors.
Validate alerting pipelines using predictable patterns that fire and resolve on a known schedule.
Simulate streaming to verify how panels handle real-time data updates.

To build a query, select a scenario from the Scenario drop-down. The query editor updates to show fields specific to that scenario. Click Run queries or use the keyboard shortcut to execute.

Note
Some scenarios run entirely in the browser (Streaming Client, Grafana Live, Grafana API, Steps, No Data Points). These scenarios don’t send queries to the backend, which means they can’t be used with Grafana Alerting or in any context that requires server-side evaluation.

Scenario reference

The scenarios are organized into the following categories. Use the table below to find the right scenario for your use case.

Scenario	Category	Purpose
Random Walk	Data generation	Random walk time series (default scenario).
Random Walk Table	Data generation	Random walk in table format with `Enum` state.
Random Walk (with error)	Data generation	Random walk that also returns an error.
Predictable Pulse	Data generation	Repeating on/off wave based on absolute time.
Predictable CSV Wave	Data generation	Custom repeating waveforms from CSV values.
Simulation	Data generation	Continuous simulation engine (flight, sine, tank).
USA generated data	Data generation	Multi-dimensional data with US state dimensions.
CSV Content	Manual input	Paste or type CSV data directly.
Steps	Manual input	Step-function data from CSV input.
CSV File	Manual input	Select from built-in CSV data files.
CSV Metric Values	Manual input	Time series from comma-separated values.
Raw Frames	Manual input	Define data frames in JSON format.
Load Apache Arrow Data	Manual input	Render base64-encoded Arrow payloads.
Table Static	Manual input	Static table with predefined columns.
Logs	Visualization testing	Simulated log data with random levels.
Node Graph	Visualization testing	Data for node graph visualizations.
Flame Graph	Visualization testing	Data for flame graph visualizations.
Trace	Visualization testing	Simulated distributed trace data.
Annotations	Visualization testing	Annotation data points.
Exponential heatmap bucket data	Visualization testing	Heatmap data with exponential buckets.
Linear heatmap bucket data	Visualization testing	Heatmap data with linear buckets.
Streaming Client	Streaming	Browser-side streaming (signal, logs, traces).
Grafana Live	Streaming	Server-side streaming via live channels.
Grafana API	Data retrieval	Fetch data from internal Grafana endpoints.
Conditional Error	Error testing	Configurable error or CSV data.
Error with source	Error testing	Error with plugin or downstream classification.
No Data Points	Error testing	Empty result with no data.
Data Points Outside Range	Error testing	Data point outside the visible time range.
Slow Query	Error testing	Configurable delay before returning data.
Query Metadata	Metadata	Returns query context metadata.

Shared query options

Every scenario displays the Scenario drop-down. Most scenarios also show an Alias field and, when the scenario defines a default, a String Input field. Some scenarios expose additional shared controls. Scenario-specific options appear below these fields.

Field	Description
Scenario	Drop-down to select the data generation type. Scenarios are listed alphabetically.
Alias	Optional display name for the series. Hidden for the Simulation and Annotations scenarios. Supports the special values `__server_names` and `__house_locations` to use built-in name sets.
String Input	Text field shown when the selected scenario provides a default string value. Used differently by each scenario.
Labels	Available for Random Walk and Predictable Pulse. Set labels using key=value syntax, for example `key="value", key2="value2"`. Use `$seriesIndex` in a value to insert the series index.
Drop percent	Available for CSV Content and CSV File. Drops a random percentage (0-100) of data points from the result.

Data generation scenarios

These scenarios produce time-series data with configurable parameters.

Random Walk

Generates random walk time-series data. This is the default scenario.

Field	Description
Series count	Number of series to generate. Default: `1`.
Start value	Initial value for the walk. Default: auto (random).
Min	Minimum value the walk can reach. Default: none.
Max	Maximum value the walk can reach. Default: none.
Spread	Controls how far each step can deviate. Default: `1`.
Noise	Adds noise to each data point. Default: `0`.
Drop (%)	Percentage of points to randomly exclude. Default: `0`.

Random Walk Table

Generates random walk data in table format with columns for Time, Value, Min, Max, Info, and State. The State column uses an enum field with values Unknown, Up, and Down. Optionally includes null values when withNil is enabled.

Random Walk (with error)

Generates random walk time-series data and also returns an error in the response. Use this to test how panels handle data responses that contain both data and errors.

Predictable Pulse

Generates a predictable pulse wave based on absolute time from the epoch, making it reproducible across runs.

Field	Description
Step	Seconds between data points. Default: `60`.
On Count	Number of data points at the start of each cycle that use the on value. Default: `3`.
Off Count	Number of data points in each cycle that use the off value. Default: `3`.
On Value	The value for “on” data points. Can be a number, `null`, or `nan`. Default: `2`.
Off Value	The value for “off” data points. Can be a number, `null`, or `nan`. Default: `1`.

The wave cycles at Step * (On Count + Off Count) seconds. Timestamps align evenly on the step interval.

With the defaults (Step=60, On Count=3, Off Count=3), the wave completes a full cycle every 6 minutes. The on value (2) holds for the first 3 data points, then the off value (1) holds for the next 3.

Predictable CSV Wave

Generates one or more predictable waves from CSV-defined values. Each wave cycles through its comma-separated values at a fixed time step.

Field	Description
Values	Comma-separated numeric values for the wave. Supports `null` and `nan`. Default: `0,0,2,2,1,1`.
Step	Seconds between data points. Default: `60`.
Name	Optional name for the series.
Labels	Optional labels in key=value format.

Click the + button on the last wave row to add another wave. Click the - button on any other row to remove it.

For example, to create two overlapping waves for comparison:

Wave 1: Values 0,1,2,3,4,5, Step 60, Name rising
Wave 2: Values 5,4,3,2,1,0, Step 60, Name falling

Simulation

Runs a simulation engine that generates data continuously. Simulation supports streaming data through Grafana Live.

Field	Description
Simulation	Simulation type: `Flight` (circling flight path), `Sine` (sine wave), or `Tank` (fill and drain a water tank).
Stream	Toggle to stream data through Grafana Live instead of returning a static result.
Interval	Tick frequency in Hz. Default: `10`.
Last	Toggle to return only the most recent value instead of the full time range.
UID	Optional unique identifier. Allows multiple instances of the same simulation type to run concurrently.

USA generated data

Generates data with US state dimensions. Useful for testing geo-map visualizations and multi-dimensional data.

Field	Description
Mode	Data format: `values-as-rows`, `values-as-fields`, `values-as-labeled-fields`, `timeseries`, or `timeseries-wide`.
Period	Time period for data generation. Default: `30m`.
Fields	Fields to include: `foo`, `bar`, `baz`. Default: all.
States	US state codes to include (for example, `CA`, `NY`, `TX`). Default: all 50 states plus DC.

Manual input scenarios

These scenarios let you provide your own data directly instead of generating it.

CSV Content

Provides a text editor where you paste or type CSV data directly. The first row is treated as headers. Use the Drop percent field to randomly exclude a percentage of data points.

For example, enter the following to create a time series with two value columns:

Time,Temperature,Humidity
2024-01-01 00:00:00,22.5,45
2024-01-01 01:00:00,21.8,48
2024-01-01 02:00:00,20.1,52

Steps

Provides a CSV text area (the same editor as CSV Content) for defining step-function data. The default content is a, b, c. This scenario is handled entirely in the browser.

CSV File

Selects from a set of built-in CSV data files. Use the Drop percent field to randomly exclude a percentage of data points.

Available files:

flight_info_by_state.csv
population_by_state.csv
gdp_per_capita.csv
js_libraries.csv
ohlc_dogecoin.csv
weight_height.csv
browser_marketshare.csv
automobiles.csv

CSV Metric Values

Generates time-series data from comma-separated values entered in the String Input field. Values are evenly distributed across the selected time range. Default: 1,20,90,30,5,0.

For example, with the default values and a 6-hour time range, the six values (1, 20, 90, 30, 5, 0) are spread across the range at equal intervals.

Raw Frames

Provides a JSON editor for defining data frames directly. The editor accepts the Grafana data frame JSON format and includes paste helpers for panel JSON and raw query results.

Load Apache Arrow Data

Loads data from a base64-encoded Apache Arrow payload entered in the String Input text area. Use this to test Arrow format rendering.

Table Static

Generates a static table with predefined columns: Time, Message, Description, and Value.

Visualization test scenarios

These scenarios generate data for testing specific visualization types.

Logs

Generates simulated log data with random log levels, container IDs, and hostnames.

Field	Description
Lines	Number of log lines to generate. Default: `10`. Maximum: `10000`.
Level	Toggle to include a separate level column in the data instead of embedding it in messages.

Node Graph

Generates data for the Node Graph visualization.

Field	Description
Data type	Type of graph data: `random`, `response_small`, `response_medium`, `random edges`, or `feature_showcase`.
Count	Number of nodes to generate. Available for `random` and `random edges` types.
Seed	Seed value for reproducible random generation. Available for `random` and `random edges` types.

Flame Graph

Generates data for the Flame Graph visualization.

Field	Description
Diff profile	Toggle to generate a differential flame graph comparing two profiles.

Trace

Generates simulated distributed trace data.

Field	Description
Span count	Number of spans in the generated trace.

Annotations

Generates synthetic annotation data points. These annotations are created entirely in the browser and are useful for testing how panels display annotation markers and overlays. They don’t query an external source or persist data.

For more information about annotations in Grafana, refer to Annotate visualizations.

Field	Description
Count	Number of annotations to generate. Default: `10`.

Exponential heatmap bucket data

Generates heatmap data with exponentially distributed bucket boundaries (1, 2, 4, 8, 16, …). Use this to test heatmap panels with exponential distributions.

Linear heatmap bucket data

Generates heatmap data with linearly distributed bucket boundaries (0, 10, 20, 30, …). Use this to test heatmap panels with linear distributions.

Streaming scenarios

These scenarios produce real-time streaming data. Data updates continuously in the browser without requiring manual query execution.

Streaming Client

Generates streaming data directly from the browser client.

Field	Description
Type	Stream type: `Signal`, `Logs`, `Fetch`, `Traces`, or `Watch`.

Additional fields depend on the selected type:

Signal: Speed (ms), Spread, Noise, Bands.
Logs, Traces, Watch: Speed (ms) only.
Fetch: URL of a remote CSV endpoint to stream incrementally.

Grafana Live

Connects to a Grafana Live channel that streams random data from the server.

Field	Description
Channel	The live channel to subscribe to. Options:

Channel	Description
`random-2s-stream`	Random stream with points every 2s.
`random-flakey-stream`	Stream that returns data at random intervals.
`random-labeled-stream`	Value with moving labels.
`random-20Hz-stream`	Random stream with points at 20 Hz.

Data retrieval scenarios

These scenarios fetch data from internal Grafana endpoints.

Grafana API

Fetches data from internal Grafana API endpoints and returns the result as a data frame. This scenario runs in the browser.

Field	Description
Endpoint	The API endpoint to query. Options:

Endpoint	Description
Data Sources	Lists configured data sources.
Search	Returns dashboard search results.
Annotations	Returns annotations.

Error and edge-case testing scenarios

These scenarios help test how Grafana handles errors, empty data, and slow responses.

Conditional Error

Produces an error or data depending on the String Input and Error type fields. When the String Input field is empty, the scenario triggers the selected error type. When the field contains CSV values (default: 1,20,90,30,5,0), it returns time-series data like the CSV Metric Values scenario, regardless of the error type.

Field	Description
Error type	Type of error to simulate: `Server panic` (backend panic), `Frontend exception` (uncaught error in the browser), or `Frontend observable` (error emitted through the query observable).

To trigger an error, clear the String Input field and select the error type you want to test.

Error with source

Returns an error with a configurable source classification.

Field	Description
Error source	Source of the error: `Plugin` (plugin error) or `Downstream` (downstream service error).

Use this to test how Grafana differentiates between plugin errors and downstream errors in alerting and error handling.

No Data Points

Returns an empty result with no data points. Use this to test how panels display when there’s no data.

Data points Outside Range

Returns a single data point with a timestamp one hour before the query time range. Use this to test how panels handle data outside the visible range.

Slow Query

Introduces a configurable delay before returning random walk data. Set the delay duration in the String Input field using Go duration syntax (for example, 5s, 1m, 500ms). Default: 5s.

Metadata scenarios

These scenarios return metadata rather than time-series data.

Query Metadata

Returns a table with query metadata including the current user’s username. Use this to verify that query context information is available.

TestData template variables

Tue, 14 Apr 2026 14:59:56 +0000

TestData template variables

Use template variables with the TestData data source to test dynamic, reusable dashboards. TestData provides a hierarchical metric tree that you can query to populate variable drop-downs with simulated values.

For an introduction to templating and template variables, refer to the Templating and Add and manage variables documentation.

Supported variable types

Variable type	Supported
Query	Yes
Custom	Yes
Data source	Yes

Create a query variable

To create a query variable using TestData:

Navigate to Dashboard settings > Variables.
Click Add variable.
Select Query as the variable type.
Select the TestData data source.
Enter your query in the Query field.

Metric tree queries

TestData generates a hierarchical metric tree with nodes named using letter combinations. The tree has 6 levels of depth, with each level containing 8 nodes labeled A through H. The query string navigates this tree using dot-separated path segments.

Query syntax

Use * as a wildcard to return all children at a given level:

Query	Result
`*`	Returns the top-level nodes: `A`, `B`, `C`, `D`, `E`, `F`, `G`, `H`.
`A.*`	Returns children of node A: `AA`, `AB`, `AC`, `AD`, `AE`, `AF`, `AG`, `AH`.
`A.AA.*`	Returns children of node AA: `AAA`, `AAB`, `AAC`, etc.
`A.AB`	Returns children of the AB node: `ABA`, `ABB`, `ABC`, etc.

Use glob patterns with curly braces to match multiple nodes:

Query	Result
`{A,B}.*`	Returns children of both A and B: `AA`, `AB`, …, `BA`, `BB`, etc.
`A.{AA,AB}.*`	Returns children of AA and AB: `AAA`, `AAB`, …, `ABA`, `ABB`, etc.

Use * after a prefix to match nodes that start with the given string:

Query	Result
`A*`	Returns all top-level nodes starting with A (only `A` at the top level).

Value queries

If your query string starts with value, TestData returns the query string itself as the result. This is useful for creating variables with specific values for testing. For example, a query of value_production returns value_production.

Example: Create a region variable

This example walks through creating a query variable that populates a drop-down with simulated region values, then using it in a panel query.

Navigate to Dashboard settings > Variables.
Click Add variable.
Set Type to Query.
Select the TestData data source.
Enter * in the Query field. This populates the variable with the top-level nodes (A through H).
Name the variable region.
Click Apply.

To use the variable in a panel:

Add a new panel and select the TestData data source.
Choose the Random Walk scenario.
In the Labels field, enter region=$region.
The panel updates when you select a different value from the region drop-down.

Example: Chain variables for cascading drop-downs

You can create dependent variables where one variable’s query references another, producing cascading drop-downs.

Create a variable named region with the query *. This returns the top-level nodes (A through H).
Create a second variable named host with the query $region.*. When the user selects A as the region, the host drop-down populates with AA, AB, AC, etc.

Changing the region selection automatically refreshes the host drop-down.

Use variables in queries

TestData interpolates template variables in the following query fields:

Labels
Alias
Scenario
String Input
CSV Content
Raw Frame Content

Use the standard Grafana variable syntax ($varname or ${varname}) in any of these fields to insert variable values.

Example

With a variable named env set to production, entering env=$env in the Labels field produces a series labeled env=production.

Limitations

TestData doesn’t support the filters variable. Filters require the data source to implement tag key and value lookups, which TestData doesn’t provide.

TestData alerting

Tue, 14 Apr 2026 14:59:56 +0000

TestData alerting

The TestData data source supports Grafana Alerting. You can use it to prototype alert rules, test threshold conditions, and verify notification pipelines without connecting to an external data source.

Before you begin

Configure the TestData data source.
Familiarize yourself with alert rules and how to create a Grafana-managed alert rule.

Choose a scenario for alerting

TestData scenarios that return time-series data work with alert rule conditions. Choose a scenario based on the behavior you want to test.

Scenario	Alerting use case
Predictable Pulse	Deterministic on/off pattern. Produces repeatable alert firing and resolving on a fixed cycle.
Random Walk	Non-deterministic time series. Useful for quick prototyping and load testing alert evaluation.
CSV Metric Values	Controlled, fixed values. Test exact threshold boundaries.
Predictable CSV Wave	Custom repeating waveforms. Test complex threshold patterns with precise control.
Random Walk (with error)	Returns both data and an error. Test how alerts handle partial failures.
Error with source	Returns a plugin or downstream error. Test alert evaluation error handling.
No Data Points	Returns empty results. Test no-data alert conditions.
Slow Query	Introduces a configurable delay. Test alert evaluation timeouts.

Scenarios that produce logs, traces, or streaming data aren’t suitable for threshold-based alert conditions.

Create an alert rule

To create an alert rule using TestData:

Navigate to Alerting > Alert rules.
Click New alert rule.
Enter a name for the rule.
Select the TestData data source.
Choose a scenario from the Scenario drop-down (for example, Predictable Pulse).
Configure the scenario options.
Add a Reduce expression to aggregate the series (for example, Last value).
Add a Threshold expression to define the condition (for example, Is above 0.5).
Set the evaluation interval and pending period.
Configure notifications and labels.
Click Save rule.

For detailed instructions, refer to Create a Grafana-managed alert rule.

Example: Predictable Pulse alert

The Predictable Pulse scenario produces a repeating on/off wave that’s ideal for testing alert rules because the firing pattern is deterministic and reproducible.

To create a Predictable Pulse alert:

Select the Predictable Pulse scenario.

Configure the pulse options:

Field	Value	Effect
Step	`60`	One data point every 60 seconds.
On Count	`3`	Three consecutive points at the “on” value.
Off Count	`6`	Six consecutive points at the “off” value.
On Value	`1`	Value during the “on” phase.
Off Value	`0`	Value during the “off” phase.

Add a Reduce expression with function Last.
Add a Threshold expression: Is above 0.5.

With this configuration, the alert fires for 3 minutes (3 x 60s on-points) and then resolves for 6 minutes (6 x 60s off-points), repeating indefinitely. Adjust the step, on count, and off count to control the timing.

Example: CSV Metric Values threshold alert

The CSV Metric Values scenario lets you define an exact sequence of data points, making it useful for testing precise threshold boundaries.

To create a threshold alert with fixed values:

Select the CSV Metric Values scenario.
Enter a comma-separated list of values in the String Input field. For example:
```
10,45,70,95,50,20
```
Add a Reduce expression with function Last.
Add a Threshold expression: Is above 80.

With this input, the series cycles through the values 10, 45, 70, 95, 50, 20. The alert fires when the reduced value exceeds 80 (the 95 data point) and resolves when it drops back below the threshold.

This approach is helpful for validating that a threshold condition triggers at the exact boundary you expect.

Test error and no-data conditions

TestData includes scenarios designed for testing how alerts respond to failures. Use these to verify that your alert rules handle edge cases correctly before connecting to production data sources.

No data

Select the No Data Points scenario. The backend returns an empty result, which triggers the alert rule’s no data state. Use this to verify that your rule is configured to alert, keep the last state, or resolve when no data is received. Configure this behavior in the alert rule’s No data and error handling section.

Errors

Select Error with source and choose the error type:

Plugin — simulates a failure in the plugin itself. The alert enters an error state.
Downstream — simulates a failure in the data source or network. The alert enters an error state with a downstream classification.

You can also use Random Walk (with error), which returns valid data alongside an error, to test how the alerting engine handles partial failures.

Timeouts

Select Slow Query and set the String Input field to a duration longer than your evaluation interval (for example, 30s for a rule evaluated every 10s). The default delay is 5s. Use this to verify timeout behavior and confirm that alerts transition to the expected state when queries take too long.

Limitations

When using TestData with Grafana Alerting, be aware of the following limitations.

Template variables aren’t supported in alert queries

Grafana evaluates alert rules on the backend without dashboard context. Template variables like $varname aren’t resolved during alert evaluation. Use fixed values in the scenario options instead.

Only time-series scenarios work with alert conditions

Alert conditions require numeric time-series data. Scenarios that produce logs (Logs), traces (Trace), graphs (Node Graph, Flame Graph), annotations (Annotations), or tables (Table Static) can’t be used as alert conditions.

Streaming scenarios aren’t evaluated by the alerting engine

The alerting engine evaluates queries at fixed intervals and doesn’t consume streaming data. Avoid using Streaming Client, Grafana Live, or Simulation with streaming enabled for alert rules.

Troubleshoot TestData data source issues

Tue, 14 Apr 2026 14:59:56 +0000

Troubleshoot TestData data source issues

This document provides solutions to common issues you may encounter when using the TestData data source. TestData is a built-in data source with no external dependencies, so most issues relate to scenario configuration or data formatting.

Query errors

These errors occur when running TestData scenarios.

“No data” or empty panels

Symptoms:

Panel displays “No data” message.
Query executes without error but returns nothing.

Possible causes and solutions:

Cause	Solution
No Data Points scenario selected	The No Data Points scenario returns empty results by design. Select a different scenario such as Random Walk.
Data Points Outside Range selected	This scenario returns a data point one hour before the query time range. Expand the time range or select a different scenario.
Empty String Input for CSV scenarios	CSV Metric Values and CSV Content require input data. Add comma-separated values or CSV content.
Time range doesn’t contain data	Some scenarios generate data relative to the query time range. Expand the dashboard time range.

Unexpected error from Conditional Error

Symptoms:

Query returns a server error or panic message.
Error appears immediately when running the query.

Solutions:

The Conditional Error scenario triggers a server panic when the String Input field is empty. This is the intended behavior for error testing.
To return data instead of an error, populate the String Input field with comma-separated values (for example, 1,20,90,30,5,0).
To change the error type, use the Error type drop-down to select between Server panic, Frontend exception, and Frontend observable.

Error with source returns an error

The Error with source scenario intentionally returns errors for testing how Grafana handles different error sources. This isn’t a misconfiguration.

Plugin error source simulates an error originating from the plugin itself.
Downstream error source simulates an error from a downstream service.

Use this scenario to test alerting rules, error displays, and error handling in custom panels.

Slow Query appears stuck

Symptoms:

Query runs for an extended period.
Panel shows a loading spinner indefinitely.

Solutions:

Check the String Input field, which controls the delay duration. The default is 5s.
Reduce the value to a shorter duration (for example, 1s or 500ms).
The field accepts Go duration syntax: 5s (seconds), 1m (minutes), 500ms (milliseconds).

Wrong data type for the visualization

Symptoms:

Panel shows “Data does not have a time field” or similar type mismatch errors.
Visualization renders but looks wrong (for example, a table when you expected a graph).

Solutions:

Match the scenario to the visualization type. For example, use the Logs scenario with the Logs panel, Node Graph with the Node Graph panel, and Trace with the Traces panel.
Time-series panels require scenarios that produce time-series data (Random Walk, Predictable Pulse, CSV Metric Values, Predictable CSV Wave).
For table panels, use Table Static, Random Walk Table, or CSV File.

Predictable Pulse pattern doesn’t match expectations

Symptoms:

The on/off pattern doesn’t align with expected times.
Values appear at unexpected intervals.

Solutions:

Predictable Pulse aligns timestamps to the step interval based on absolute time from the epoch, not from the start of the time range. This means the pattern starts at the same point regardless of when you load the dashboard.
Verify the cycle duration matches your intent: the full cycle is Step * (On Count + Off Count) seconds.
Check that On Value and Off Value are set correctly. The defaults are 2 and 1, not 1 and 0.

CSV and data input errors

These errors occur with scenarios that accept user-provided data.

CSV Content or CSV Metric Values return unexpected results

Symptoms:

Data doesn’t match expectations.
Fewer data points than expected.
Parsing errors.

Solutions:

Verify CSV formatting: headers in the first row, commas as delimiters, numeric values unquoted.
For CSV Metric Values, enter only comma-separated numbers in the String Input field (for example, 1,20,90,30,5,0).
The special values null and nan are supported in Predictable CSV Wave values. Use null for missing data points and nan for Not-a-Number values.
Check for trailing commas or extra whitespace in your input.

Raw Frames JSON parse errors

Symptoms:

Error message about invalid JSON.
Panel fails to render.

Solutions:

Validate that the JSON matches the Grafana data frame format.
Use the paste helpers in the editor to import data from panel JSON or raw query results.
Verify that field types are consistent within each field array.

Streaming errors

These errors occur with the Streaming Client and Grafana Live scenarios.

Streaming Client doesn’t update

Symptoms:

Panel shows initial data but doesn’t update.
No new data points appear over time.

Solutions:

Verify the Speed field is set to a reasonable value (in milliseconds). Lower values produce faster updates.
For the Fetch type, verify the URL is accessible from the browser.
Check the browser console for WebSocket or network errors.

Grafana Live channel shows no data

Symptoms:

Panel remains empty after selecting a channel.
No streaming data appears.

Solutions:

Confirm the selected channel matches one of the available options: random-2s-stream, random-flakey-stream, random-labeled-stream, or random-20Hz-stream.
Verify that Grafana Live is enabled in your Grafana instance.
Check the Grafana server logs for Live connection errors.

Template variable errors

These errors occur when using TestData with dashboard template variables.

Variable drop-down is empty

Symptoms:

Variable drop-down shows no options.
Preview in the variable editor returns zero values.

Solutions:

Verify the query string navigates valid nodes in the metric tree. Use * to return all top-level nodes.
Check that dot-separated path segments match the tree structure (for example, A.* returns children of node A). An invalid path like Z.* returns nothing because Z doesn’t exist in the tree.
Verify the TestData data source is selected in the variable editor.
Click Run query in the variable editor preview to test.

Chained variable doesn’t update

Symptoms:

A dependent variable (for example, $region.*) doesn’t refresh when the parent variable changes.
The drop-down shows stale values from a previous selection.

Solutions:

Set the dependent variable’s Refresh option to On dashboard load or On time range change in the variable editor.
Verify the query uses the correct parent variable syntax (for example, $region.* not region.*).

Variable value not interpolated in queries

Symptoms:

Panel shows the literal string $varname instead of the variable value.
Labels or data don’t change when the variable selection changes.

Solutions:

Verify you’re using the correct variable syntax: $varname or ${varname}.
TestData interpolates variables in these fields only: Labels, Alias, Scenario, String Input, CSV Content, and Raw Frame Content. Other fields don’t support variable substitution.

Alerting errors

These errors occur when using TestData with Grafana Alerting.

Alert rule shows “no data” unexpectedly

Symptoms:

Alert rule status shows No Data even though the scenario works in a panel.
Alert never transitions to firing or normal.

Solutions:

Verify you’re using a backend-evaluated scenario. Browser-only scenarios (Streaming Client, Grafana Live, Grafana API, Steps, No Data Points) return empty results when evaluated by the alerting engine. Use a backend scenario like Random Walk or Predictable Pulse instead.
Confirm the scenario is returning time-series data. Scenarios that produce logs (Logs), traces (Trace), graphs (Node Graph, Flame Graph), or tables (Table Static) can’t be used as alert conditions.
Check that the String Input field isn’t empty for scenarios that require it (for example, CSV Metric Values).

Alert rule never fires

Symptoms:

Alert rule stays in Normal state.
Data is visible in the panel but the alert condition is never met.

Solutions:

If using Random Walk, the values are non-deterministic and may not exceed your threshold. Use Predictable Pulse or CSV Metric Values with values that reliably cross the threshold.
Verify the Reduce expression is aggregating correctly. For example, Last returns the most recent value, while Mean averages the series.
Check the Threshold expression. Click Preview in the alert rule editor to see the evaluated value.
Ensure the evaluation interval is long enough for the scenario to produce data points. A Predictable Pulse with Step=60 needs at least a 60-second evaluation window.

Template variables don’t resolve in alert rules

Symptoms:

Alert rule error mentions unresolved variables.
Alert query uses $varname syntax but the variable isn’t replaced.

Solutions:

Grafana evaluates alert rules on the backend without dashboard context. Template variables like $varname aren’t resolved during alert evaluation. Replace variable references with fixed values in the scenario options.

For more information, refer to the alerting limitations.

Alert evaluation timeout

Symptoms:

Alert rule transitions to Error state.
Logs show a timeout during query evaluation.

Solutions:

If you’re using the Slow Query scenario, reduce the delay in the String Input field to a value shorter than the evaluation interval.
For other scenarios, verify that the query isn’t producing an excessive number of data points. Reduce the time range or increase the step interval.

Enable debug logging

To capture detailed error information for troubleshooting:

Set the Grafana log level to debug in the configuration file:
ini
```
[log]
level = debug
```
Review logs in /var/log/grafana/grafana.log (or your configured log location).
Look for entries containing testdata or testdatasource for scenario-specific details.
Reset the log level to info after troubleshooting to avoid excessive log volume.

Get additional help

If you’ve tried the solutions in this document and still encounter issues:

Check the Grafana community forums for similar issues.
Review Grafana GitHub issues for known bugs.
When reporting issues, include:
- Grafana version
- Selected scenario and its configuration
- Error messages (redact sensitive information)
- Steps to reproduce