# Working in Grafana version 12
` to the end. To view fiscal periods, use `fQ (fiscal quarter)` and `fy (fiscal year)` time units.
The plus operator enables you to step forward in time, relative to now. For example, you can use this feature to look at predicted data in the future.
The following table provides example relative ranges.
| Example relative range | From | To |
| --- | --- | --- |
| Last 5 minutes | `now-5m` | `now` |
| The day so far | `now/d` | `now` |
| This week | `now/w` | `now/w` |
| This week so far | `now/w` | `now` |
| This month | `now/M` | `now/M` |
| This month so far | `now/M` | `now` |
| Previous Month | `now-1M/M` | `now-1M/M` |
| This year so far | `now/Y` | `now` |
| This Year | `now/Y` | `now/Y` |
| Previous fiscal year | `now-1y/fy` | `now-1y/fy` |
**Note**
Grafana Alerting does not support the following syntaxes:
`now+n` for future timestamps.
`now-1n/n` for *start of n until end of n*, because this is an absolute timestamp.
**Common time range controls**
The dashboard and panel time controls have a common user interface. The following describes common time range controls.
+ Current time range, also called the *time picker*, shows the time range currently displayed in the dashboard or panel you are viewing. Hover your cursor over the field to see the exact time stamps in the range and their source (such as the local browser time). Click the *current time range* to change it. You can change the current time using a *relative time range*, such as the last 15 minutes, or an absolute time range, such as `2020-05-14 00:00:00` to `2020-05-15 23:59:59`.
+ The **relative time range** can be selected from the **Relative time ranges** list. You can filter the list using the input field at the top. Some examples of time ranges include *Last 30 minutes*, *Last 12 hours*, *Last 7 days*, *Last 2 years*, *Yesterday*, *Day before yesterday*, *This day last week*, *Today so far*, *This week so far*, and *This month so far*.
+ **Absolute time range** can be set in two ways: Typing exact time values or relative time values into the **From** and **To** fields and clicking **Apply time range**, or clicking a date or date range from the calendar displayed when you click the **From** or **To** field. To apply your selections, click **Apply time range**. You can also choose from a list of recently used absolute time ranges.
+ **Semi-relative time range** can be selected in the absolute time range settings. For example, to show activity since a specific date, you can choose an absolute time for the start time, and a relative time (such as `now`) for the end time.
Using a semi-relative time range, as time progresses, your dashboard will automatically and progressively zoom out to show more history and fewer details. At the same rate, as high data resolution decreases, historical trends over the entire time period will become more clear.
**Note**
Alerting does not support semi-relative time ranges.
+ **Zoom out** by selecting the zoom out icon (or by using Cmd\$1Z or Ctrl\$1Z as a keyboard shortcut). This increases the view, showing a larger time range in the dashboard or panel visualization.
+ **Zoom in** by selecting a time range you want to view on the graph in the visualization.
**Note**
Zooming in is only applicable to graph visualizations.
**Refresh dashboards**
Click the **Refresh dashboard** icon to immediately run every query on the dashboard and refresh the visualizations. Grafana cancels any pending requests when you trigger a refresh.
By default, Grafana does not automatically refresh the dashboard. Queries run on their own schedule according to the panel settings. However, if you want to regularly refresh the dashboard, then click the down arrow next to the **Refresh dashboard** icon and then select a refresh interval.
**Control the time range using a URL**
You can control the time range of a dashboard by providing the following query parameters in the dashboard URL.
+ `from` defines the lower limit of the time range, specified in ms epoch, or [relative time](#v12-dash-setting-dashboard-time-range).
+ `to` defines the upper limit of the time range, specified in ms epoch, or relative time.
+ `time` and `time.window` defines a time range from `time-time.window/2` to `time+time.window/2`. Both parameters should be specified in ms. For example `?time=1500000000000&time.window=10000` results in 10s time range from 1499999995000 to 1500000005000.
# Building dashboards
*** button in the diff view. Selecting either of these will prompt you to confirm the restoration.
After restoring to a previous version, a new version will be created containing the same exact data as the previous version, only with a different version number. This is indicated in the **Notes column** for the row in the new dashboard version. This ensures your previous dashboard versions are not affected by the change.
# Managing dashboard links
**.
The playlist displays each dashboard for the time specified in the `Interval` field, set when creating or editing a playlist. After a playlist starts, you can control it using the navigation bar at the top of your screen.
| Mode | Description |
| --- | --- |
| Normal mode | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/grafana/latest/userguide/v12-dash-managing-playlists.html) |
| TV mode | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/grafana/latest/userguide/v12-dash-managing-playlists.html) |
| TV mode (with auto fit panels) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/grafana/latest/userguide/v12-dash-managing-playlists.html) |
| Kiosk mode | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/grafana/latest/userguide/v12-dash-managing-playlists.html) |
| Kiosk mode (with auto fit panels) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/grafana/latest/userguide/v12-dash-managing-playlists.html) |
**Controlling a playlist**
You can control a playlist in **Normal** or **TV** mode after it has started, using the navigation bar at the top of your screen. Press the `Esc` key in your keyboard to stop the playlist.
| Button | Action |
| --- | --- |
| Next (double-right arrow) | Advances to the next dashboard. |
| Back (left arrow) | Returns to the previous dashboard. |
| Stop (square) | Ends the playlist, and exits to the current dashboard. |
| Cycle view mode (monitor icon) | Rotates the display of the dashboards in different view modes. |
| Time range | Displays data within a time range. It can be set to display the last 5 minutes up to 5 years ago, or a custom time range, using the down arrow. |
| Refresh (circle arrow) | Reloads the dashboard, to display the current data. It can be set to reload automatically every 5 seconds to 1 day, using the dropdown arrow. |
## Creating a playlist
=value.
**Examples**
Variables are listed in dropdown lists across the top of the screen. Select different variables to see how the visualizations change.
To see variable settings, navigate to **Dashboard Settings > Variables**. Click a variable in the list to see its settings.
Variables can be used in titles, descriptions, text panels, and queries. Queries with text that starts with `$` are templates. Not all panels will have template queries.
**Variable best practices**
+ Variable dropdown lists are displayed in the order they are listed in the variable list in **Dashboard settings**.
+ Put the variables that you will change often at the top, so they will be shown first (far left on the dashboard).
+ Variables preselect the topmost value in the dropdown list by default. If you want to choose an empty value instead, change the variable settings, as follows:
1. Select the **Include All Option** checkbox.
1. In the **Custom all value** field, enter the value `+`.
**Topics**
+ [
# Add and manage variables
](v12-dash-variable-add.md)
+ [
# Inspect Variables
](v12-dash-variable-add-inspect.md)
+ [
# Variable syntax
](v12-dash-variable-syntax.md)
# Add and manage variables
[ ^ " ] + ) |chip=" (?[ ^ " ] + )/g
```
Would produce the following dropdown list:
```
Display Name Value
------------ -------------------------
enp216s0f0np0 0000:d7:00_0_0000:d8:00_0
enp216s0f0np1 0000:d7:00_0_0000:d8:00_1
enp216s0f0np2 0000:d7:00_0_0000:d8:00_2
enp216s0f0np3 0000:d7:00_0_0000:d8:00_3
```
Only `text` and `value` capture group names are supported.
# Inspect Variables
}` – This format gives you more control over how Grafana interprets values. For more information, see *Advanced variable format options*, following this list.
+ `[[varname]]` – Do not use. This syntax is old and has been deprecated. It will be removed in a future release.
Before queries are sent to your data source the query is *interpolated*, meaning the variable is replaced with its current value. During interpolation, the variable value might be *escaped* in order to conform to the syntax of the query language and where it is used. For example, a variable used in a regex expression in an InfluxDB or Prometheus query will be regex escaped.
**Advanced variable format options**
The formatting of the variable interpolation depends on the data source, but there are some situations where you might want to change the default formatting.
For example, the default for the MySQL data source is to join multiple values as comma-separated with quotes: `'server01','server02'`. In some cases, you might want to have a comma-separated string without quotes: `server01,server02`. You can make that happen with advanced variable formatting options listed below.
**General syntax**
Syntax: `${var_name:option}`
If any invalid formatting option is specified, then `glob` is the default/fallback option.
**CSV**
Formats variables with multiple values as a comma-separated string.
```
servers = [ 'test1', 'test2' ]
String to interpolate: '${servers:csv}'
Interpolation result: 'test1,test2'
```
**Distributed - OpenTSDB**
Formats variables with multiple values in custom format for OpenTSDB.
```
servers = [ 'test1', 'test2' ]
String to interpolate: '${servers:distributed}'
Interpolation result: 'test1,servers=test2'
```
**Doublequote**
Formats single- and multi-valued variables into a comma-separated string, escapes `"` in each value by `\"` and quotes each value with `"`.
```
servers = [ 'test1', 'test2' ]
String to interpolate: '${servers:doublequote}'
Interpolation result: '"test1","test2"'
```
**Glob - Graphite**
Formats variables with multiple values into a glob (for Graphite queries).
```
servers = [ 'test1', 'test2' ]
String to interpolate: '${servers:glob}'
Interpolation result: '{test1,test2}'
```
**JSON**
Formats variables with multiple values as a comma-separated string.
```
servers = [ 'test1', 'test2' ]
String to interpolate: '${servers:json}'
Interpolation result: '["test1", "test2"]'
```
**Lucene - Elasticsearch**
Formats variables with multiple values in Lucene format for Elasticsearch.
```
servers = [ 'test1', 'test2' ]
String to interpolate: '${servers:lucene}'
Interpolation result: '("test1" OR "test2")'
```
**Percentencode**
Formats single and multivalued variables for use in URL parameters.
```
servers = [ 'foo()bar BAZ', 'test2' ]
String to interpolate: '${servers:percentencode}'
Interpolation result: 'foo%28%29bar%20BAZ%2Ctest2'
```
**Pipe**
Formats variables with multiple values into a pipe-separated string.
```
servers = [ 'test1.', 'test2' ]
String to interpolate: '${servers:pipe}'
Interpolation result: 'test1.|test2'
```
**Raw**
Turns off data source-specific formatting, such as single quotes in an SQL query.
```
servers = [ 'test.1', 'test2' ]
String to interpolate: '${var_name:raw}'
Interpolation result: 'test.1,test2'
```
**Regex**
Formats variables with multiple values into a regex string.
```
servers = [ 'test1.', 'test2' ]
String to interpolate: '${servers:regex}'
Interpolation result: '(test1\.|test2)'
```
**Singlequote**
Formats single- and multi-valued variables into a comma-separated string, escapes `'` in each value by `\'` and quotes each value with `'`.
```
servers = [ 'test1', 'test2' ]
String to interpolate: '${servers:singlequote}'
Interpolation result: "'test1','test2'"
```
**Sqlstring**
Formats single- and multi-valued variables into a comma-separated string, escapes `'` in each value by `''` and quotes each value with `'`.
```
servers = [ "test'1", "test2" ]
String to interpolate: '${servers:sqlstring}'
Interpolation result: "'test''1','test2'"
```
**Text**
Formats single- and multi-valued variables into their text representation. For a single variable, it will just return the text representation. For multi-valued variables, it will return the text representation combined with `+`.
```
servers = [ "test1", "test2" ]
String to interpolate: '${servers:text}'
Interpolation result: "test1 + test2"
```
**Query parameters**
Formats single- and multi-valued variables into their query parameter representation. Example: `var-foo=value1&var-foo=value2`
```
servers = [ "test1", "test2" ]
String to interpolate: '${servers:queryparam}'
Interpolation result: "var-servers=test1&var-servers=test2"
```
# Assessing dashboard usage
[${__range_s}s]) != )
```
**Special data sources**
Grafana also includes three special data sources: **Grafana**, **Mixed**, and **Dashboard**. For more information, see [Connect to data sources](AMG-data-sources.md).
## Navigate the query tab
number = number
+ Number series = series
+ Series series = series
Because expressions work with multiple series or numbers represented by a single variable, binary operations also perform a union (join) between the two variables. This is done based on the identifying labels associated with each individual series or number.
So if you have numbers with labels like `{host=web01}` in `$A` and another number in `$B` with the same labels then the operation is performed between those two items within each variable, and the result will share the same labels. The rules for the behavior of this union are as follows:
+ An item with no labels will join to anything.
+ If both `$A` and `$B` each contain only one item (one series, or one number), they will join.
+ If labels are exact match they will join.
+ If labels are a subset of the other, for example an item in `$A` is labeled `{host=A,dc=MIA}` and an item in `$B` is labeled `{host=A}` they will join.
+ If within a variable such as `$A` there are different tag keys for each item, the join behavior is undefined.
The relational and logical operators return 0 for false 1 for true.
**Math Functions**
While most functions exist in the own expression operations, the math operation does have some functions that similar to math operators or symbols. When functions can take either numbers or series, than the same type as the argument will be returned. When it is a series, the operation of performed for the value of each point in the series.
*abs*
abs returns the absolute value of its argument which can be a number or a series. For example `abs(-1)` or `abs($A)`.
*is\$1inf*
is\$1inf takes a number or a series and returns `1` for `Inf` values (negative or positive) and `0` for other values. For example `is_inf($A)`.
**Note**
If you need to specifically check for negative infinity for example, you can do a comparison like `$A == infn()`.
*is\$1nan*
is\$1nan takes a number or a series and returns `1` for `NaN` values and `0` for other values. For example `is_nan($A)`. This function is required for this check because `NaN` is not equal to `NaN`.
*is\$1null*
is\$1null takes a number or a series and returns `1` for `null` values and `0` for other values. For example `is_null($A)`.
*is\$1number*
is\$1number takes a number or a series and returns `1` for all real number values and `0` for other values (which are `null`, `Inf+`, `Inf-`, and `NaN`). For example `is_number($A)`.
*log*
Log returns the natural logarithm of its argument which can be a number or a series. If the value is less than 0, `NaN` is returned. For example `log(-1)` or `log($A)`.
*inf, infn, nan, and null*
The inf, infn, nan, and null functions all return a single value of the name. They primarily exist for testing. Example: `null()`.
*round*
Round returns a rounded integer value. For example, `round(3.123)` or `round($A)`.
*ceil*
Ceil rounds the number up to the nearest integer value. For example, `ceil(3.123)` returns `4`.
*floor*
Floor rounds the number down to the nearest integer value. For example, `floor(3.123`) returns `3`.
**Reduce**
Reduce takes one or more time series returned from a query or an expression and turns each series into a single number. The labels of the time series are kept as labels on each outputted reduced number.
*Fields:*
+ **Function** – The reduction function to use
+ **Input** – The variable (refID (such as `A`)) to resample
+ **Mode** – Allows control behavior of reduction function when a series contains non-numerical values (null, NaN, \$1-Inf)
**Reduction Functions**
*Count*
Count returns the number of points in each series.
*Mean*
Mean returns the total of all values in each series divided by the number of points in that series. In `strict` mode if any values in the series are null or nan, or if the series is empty, NaN is returned.
*Min and Max*
Min and Max return the smallest or largest value in the series respectively. In `strict` mode if any values in the series are null or nan, or if the series is empty, NaN is returned.
*Sum*
Sum returns the total of all values in the series. If series is of zero length, the sum will be 0. In `strict` mode if there are any NaN or Null values in the series, NaN is returned.
*Last*
Last returns the last number in the series. If the series has no values then returns NaN.
**Reduction Modes**
*Strict*
In Strict mode the input series is processed as is. If any values in the series are non-numeric (null, NaN or \$1-Inf), NaN is returned.
*Drop Non-Numeric*
In this mode all non-numeric values (null, NaN or \$1-Inf) in the input series are filtered out before running the reduction function.
*Replace Non-Numeric*
In this mode all non-numeric values are replaced by a pre-defined value.
**Resample**
Resample changes the time stamps in each time series to have a consistent time interval. The main use case is so you can resample time series that do not share the same timestamps so math can be performed between them. This can be done by resample each of the two series, and then in a Math operation referencing the resampled variables.
*Fields:*
+ **Input** – The variable of time series data (refID (such as `A`)) to resample
+ **Resample** to – The duration of time to resample to, for example `10s`. Units can be `s` for seconds, `m` for minutes, `h` for hours, `d` for days, `w` for weeks, and `y` for years.
+ **Downsample** – The reduction function to use when there are more than one data point per window sample. See the reduction operation for behavior details.
+ **Upsample** – The method to use to fill a window sample that has no data points.
+ **pad** fills with the last knowm value
+ **backfill** with next known value
+ **fillna** to fill empty sample windows with NaNs
## Write an expression
** for a custom unit that should go after the value.
+ **prefix:** for a custom unit that should go before the value.
+ **time:** For custom date time formats, type for example `time:YYYY-MM-DD`. See [format](https://momentjs.com/docs/#/displaying/) in the *Moment.js Documentation* for the format syntax and options.
+ **si:** for custom SI units. For example: `si: mF`. This is a bit more advanced as you can specify both a unit and the source data scale. So if your source data is represented as milli (thousands of) something prefix the unit with that SI scale character.
+ **count:** for a custom count unit.
+ **currency:** for custom a currency unit.
You can also paste a native emoji in the unit picker and pick it as a custom unit.
### String units
` – label’s value to the URL. If your label contains dots, then use `__field.labels[""]` syntax.
### Value variables
/explore?panes=&schemaVersion=&orgId=
```
where:
+ `org_id` is the organization ID
+ `schema_version` is the schema version (should be set to the latest version, which is `1`.
+ `panes` is a url-encoded JSON object of panes, where each key is the pane ID and each value is an object matching the following schema:
```
{
datasource: string; // the pane's root datasource UID, or `-- Mixed --` for mixed datasources
queries: {
refId: string; // an alphanumeric identifier for this query, must be unique within the pane, i.e. "A", "B", "C", etc.
datasource: {
uid: string; // the query's datasource UID ie: "AD7864H6422"
type: string; // the query's datasource type-id, i.e: "loki"
}
// ... any other datasource-specific query parameters
}[]; // array of queries for this pane
range: {
from: string; // the start time, in milliseconds since epoch
to: string; // the end time, in milliseconds since epoch
}
}
```
**Note**
The `from` and `to` fields also accept relative ranges as described in the [Setting dashboard time range](v12-dash-using-dashboards.md#v12-dash-setting-dashboard-time-range) topic.
## Share shortened link
/public/emails/ng_alert_notification.html`. You can edit this file to change the appearance of all alerting emails.
# Alertmanager
auth =
}
```
## Provision contact points and templates
* with your Slack webhook URL (or other contact point details).
This example creates a contact point that sends alert notifications to Slack.
```
resource "grafana_contact_point" "my_slack_contact_point" {
name = "Send to My Slack Channel"
slack {
url =
text = <
Notification policies tell Grafana how to route alert instances, as opposed to where. They connect firing alerts to your previously defined contact points using a system of labels and matchers.
**To provision notification policies and routing**
1. Copy this code block into a .tf file on your local machine.
In this example, the alerts are grouped by `alertname`, which means that any notifications coming from alerts which share the same name, are grouped into the same Slack message.
If you want to route specific notifications differently, you can add sub-policies. Sub-policies allow you to apply routing to different alerts based on label matching. In this example, we apply a mute timing to all alerts with the label a=b.
```
resource "grafana_notification_policy" "my_policy" {
group_by = ["alertname"]
contact_point = grafana_contact_point.my_slack_contact_point.name
group_wait = "45s"
group_interval = "6m"
repeat_interval = "3h"
policy {
matcher {
label = "a"
match = "="
value = "b"
}
group_by = ["..."]
contact_point = grafana_contact_point.a_different_contact_point.name
mute_timings = [grafana_mute_timing.my_mute_timing.name]
policy {
matcher {
label = "sublabel"
match = "="
value = "subvalue"
}
contact_point = grafana_contact_point.a_third_contact_point.name
group_by = ["..."]
}
}
}
```
1. In the mute\$1timings field, link a mute timing to your notification policy.
1. Run the command `terraform apply`.
1. Go to the Grafana UI and check the details of your notification policy.
**Note**
You cannot edit resources provisioned from Terraform from the UI. This ensures that your alerting stack always stays in sync with your code.
1. Click **Test** to verify that the notification point is working correctly.
## Provision mute timings
****
This documentation topic is designed for Grafana workspaces that support **Grafana version 12.x**.
For Grafana workspaces that support Grafana version 10.x, see [Working in Grafana version 10](using-grafana-v10.md).
For Grafana workspaces that support Grafana version 9.x, see [Working in Grafana version 9](using-grafana-v9.md).
For Grafana workspaces that support Grafana version 8.x, see [Working in Grafana version 8](using-grafana-v8.md).
You can verify that your alerting resources were created in Grafana.
**To view your provisioned resources in Grafana**
1. Open your Grafana instance.
1. Navigate to Alerting.
1. Click an alerting resource folder, for example, Alert rules.
Provisioned resources are labeled **Provisioned**, so that it is clear that they were not created manually.
**Note**
You cannot edit provisioned resources from Grafana. You can only change the resource properties by changing the provisioning file and restarting Grafana or carrying out a hot reload. This prevents changes being made to the resource that would be overwritten if a file is provisioned again or a hot reload is carried out.
# Configure alerting