Build a panel plugin
Introduction​
Panels, which allow you to visualize data in different ways, are one of the fundamental building blocks of Grafana. Grafana has several types of panels already included, and many more available in the Grafana plugin catalog.
To add support for other visualizations, you can create your own panel plugin. Panels are ReactJS components and can be scaffolded with the create-plugin
tool.
For more information about panels, refer to the documentation on Panels.
Prerequisites​
- Grafana v10.0 or later
- LTS version of Node.js
Create a new plugin​
The Grafana create-plugin tool is a CLI application that simplifies Grafana plugin development, so that you can focus on code. The tool scaffolds a starter plugin, all the required configuration, and a development environment using Docker Compose for you.
-
In a new directory, create a plugin from a template using the create-plugin tool. When prompted for the kind of plugin, select panel:
npx @grafana/create-plugin@latest
-
Go to the directory of your newly created plugin:
cd <your-plugin>
-
Install the dependencies:
npm install
-
Build the plugin:
npm run dev
-
Start Grafana:
docker compose up
- Open Grafana, by default http://localhost:3000/, and then go to Administration > Plugins. Make sure that your panel plugin is there.
You can also verify that Grafana has discovered your plugin by checking the logs:
INFO[01-01|12:00:00] Plugin registered logger=plugin.loader pluginID=<your-plugin>
Anatomy of a plugin​
Every plugin you create requires at least two files: plugin.json
and src/module.ts
.
plugin.json
​
When Grafana starts, it scans the plugin directory for any subdirectory that contains a plugin.json
file. The plugin.json
file contains information about your plugin and tells Grafana about what capabilities and dependencies your plugin needs.
While certain plugin types can have specific configuration options, let's look at the mandatory ones:
type
tells Grafana what type of plugin to expect. Grafana supports three types of plugins:panel
,datasource
, andapp
.name
is what users will see in the list of plugins. If you're creating a data source, this is typically the name of the database it connects to, such as Prometheus, PostgreSQL, or Stackdriver.id
uniquely identifies your plugin and should follow this naming convention:<$organization-name>-<$plugin-name>-<$plugin-type>
. The create-plugin tool correctly configures this based on your responses to its prompts.
To see all the available configuration settings for the plugin.json
, refer to the plugin.json Schema.
module.ts
​
After discovering your plugin, Grafana loads the module.js
file, the entrypoint for your plugin. module.js
exposes the implementation of your plugin, which depends on the type of plugin you're building.
Specifically, src/module.ts
needs to export a class that extends GrafanaPlugin, and can be any of the following:
Panel plugins​
Panel properties​
The PanelProps interface exposes runtime information about the panel, such as panel dimensions, and the current time range.
You can access the panel properties through the props
argument, as seen in your plugin.
export const SimplePanel: React.FC<Props> = ({ options, data, width, height }) => {
Development workflow​
Next, you'll learn the basic workflow of making a change to your panel, building it, and reloading Grafana to reflect the changes you made.
First, you need to add your panel to a dashboard:
- Open Grafana in your browser.
- Create a new dashboard, and add a new panel.
- Select your panel from the list of visualization types.
- Save the dashboard.
Now that you can view your panel, try making a change to the panel plugin:
-
In
SimplePanel.tsx
, change the fill color of the circle. For example, to change it to green:src/components/SimplePanel.tsx<circle style={{ fill: theme.visualization.getColorByName('green') }} r={100} />
-
Save the file.
-
In the browser, reload Grafana to see the new changes.
Add panel options​
Sometimes you want to offer the users of your panel an option to configure the behavior of your plugin. By configuring panel options for your plugin, your panel will be able to accept user input.
In the previous step, you changed the fill color of the circle in the code. Let's change the code so that the plugin user can configure the color from the panel editor.
Add an option​
Panel options are defined in a panel options object. SimpleOptions
is an interface that describes the options object.
-
In
types.ts
, add aCircleColor
type to hold the colors the users can choose from:type CircleColor = 'red' | 'green' | 'blue';
-
In the
SimpleOptions
interface, add a new option calledcolor
:color: CircleColor;
Here's the updated options definition:
type SeriesSize = 'sm' | 'md' | 'lg';
type CircleColor = 'red' | 'green' | 'blue';
// interface defining panel options type
export interface SimpleOptions {
text: string;
showSeriesCount: boolean;
seriesCountSize: SeriesSize;
color: CircleColor;
}
Add an option control​
To change the option from the panel editor, you need to bind the color
option to an option control.
Grafana supports a range of option controls, such as text inputs, switches, and radio groups.
Let's create a radio control and bind it to the color
option.
-
Add the control at the end of the builder:
src/module.ts.addRadio({
path: 'color',
name: 'Circle color',
defaultValue: 'red',
settings: {
options: [
{
value: 'red',
label: 'Red',
},
{
value: 'green',
label: 'Green',
},
{
value: 'blue',
label: 'Blue',
},
],
}
});The
path
is used to bind the control to an option. You can bind a control to nested option by specifying the full path within a options object, for examplecolors.background
.
Grafana builds an options editor for you and displays it in the panel editor sidebar in the Display section.
Use the new option​
You're almost done. You've added a new option and a corresponding control to change the value. But the plugin isn't using the option yet. Let's change that.
-
To convert option value to the colors used by the current theme, add the following statement right before the
return
statement inSimplePanel.tsx
.src/components/SimplePanel.tsxlet color = theme.visualization.getColorByName(options.color);
-
Configure the circle to use the color.
src/components/SimplePanel.tsx<g>
<circle style={{ fill: color }} r={100} />
</g>
Now, when you change the color in the panel editor, the fill color of the circle changes as well.
Create dynamic panels using data frames​
Most panels visualize dynamic data from a Grafana data source. In this step, you'll create one circle per series, each with a radius equal to the last value in the series.
To use data from queries in your panel, you need to set up a data source. If you don't have one available, you can use the TestData data source while developing.
The results from a data source query within your panel are available in the data
property inside your panel component.
const { data } = props;
data.series
contains the series returned from a data source query. Each series is represented as a data structure called data frame. A data frame resembles a table, where data is stored by columns, or fields, instead of rows. Every value in a field share the same data type, such as string, number, or time.
Here's an example of a data frame with a time field, Time
, and a number field, Value
:
Time | Value |
---|---|
1589189388597 | 32.4 |
1589189406480 | 27.2 |
1589189513721 | 15.0 |
Let's see how you can retrieve data from a data frame and use it in your visualization.
-
Get the last value of each field of type
number
, by adding the following toSimplePanel.tsx
, before thereturn
statement:src/components/SimplePanel.tsxconst radii = data.series
.map((series) => series.fields.find((field) => field.type === 'number'))
.map((field) => field?.values.get(field.values.length - 1));radii
will contain the last values in each of the series that are returned from a data source query. You'll use these to set the radius for each circle. -
Change the
svg
element to the following:src/components/SimplePanel.tsx<svg
className={styles.svg}
width={width}
height={height}
xmlns="http://www.w3.org/2000/svg"
xmlnsXlink="http://www.w3.org/1999/xlink"
viewBox={`0 -${height / 2} ${width} ${height}`}
>
<g fill={color}>
{radii.map((radius, index) => {
const step = width / radii.length;
return <circle r={radius} transform={`translate(${index * step + step / 2}, 0)`} />;
})}
</g>
</svg>Note how we're creating a
<circle>
element for each value inradii
:src/components/SimplePanel.tsx{
radii.map((radius, index) => {
const step = width / radii.length;
return <circle r={radius} transform={`translate(${index * step + step / 2}, 0)`} />;
});
}We use the
transform
here to distribute the circle horizontally within the panel. -
Rebuild your plugin and try it out by adding multiple queries to the panel. Refresh the dashboard.
If you want to know more about data frames, check out our introduction to Data frames.
Summary​
In this tutorial you learned how to create a custom visualization for your dashboards.