Grafanalib

https://grafanalib.readthedocs.io/en/stable
Admin
Grafanalib is a Python library for generating Grafana dashboards and alerts from code, simplifying...
Tokens:9,419
Snippets:82
Trust Score:8.3
Update:3 months ago
Show doc for...
Tokens:
Raw
### Install grafanalib for smoke-testing

Source: https://grafanalib.readthedocs.io/en/stable/releasing.html

Installs the package locally to verify the build before official release.

```bash
$ python setup.py install --user
```

--------------------------------

### Set up local development environment

Source: https://grafanalib.readthedocs.io/en/stable/getting-started.html

Commands to create a virtual environment and install the package in editable mode for development.

```bash
$ virtualenv .env
$ . ./.env/bin/activate
$ pip install -e .
```

--------------------------------

### Define StatValueMappings

Source: https://grafanalib.readthedocs.io/en/stable/api/grafanalib.html

Example of initializing StatValueMappings with a list of StatValueMappingItem objects.

```python
mappings=[
     

core.StatValueMappings(
    
core.StatValueMappingItem(‘Offline’, ‘0’, ‘red’), # Value must a string core.StatValueMappingItem(‘Online’, ‘1’, ‘green’)
),
],
```

--------------------------------

### Install grafanalib via pip

Source: https://grafanalib.readthedocs.io/en/stable/getting-started.html

Use this command to install the package in your Python environment.

```bash
$ pip install grafanalib
```

--------------------------------

### Upgrade grafanalib

Source: https://grafanalib.readthedocs.io/en/stable/releasing.html

Updates the installed package to the latest version to verify the release.

```bash
$ pip intall grafanalib -U
```

--------------------------------

### Run all tests and build tasks

Source: https://grafanalib.readthedocs.io/en/stable/CONTRIBUTING.html

Execute the full suite of tests and build processes using the make utility.

```bash
$ make all
```

--------------------------------

### Define a dashboard with panels in Python

Source: https://grafanalib.readthedocs.io/en/stable/getting-started.html

Configures a dashboard containing TimeSeries and GaugePanel elements using random walk and Prometheus datasources.

```python
from grafanalib.core import (
    Dashboard, TimeSeries, GaugePanel,
    Target, GridPos,
    OPS_FORMAT
)

dashboard = Dashboard(
    title="Python generated example dashboard",
    description="Example dashboard using the Random Walk and default Prometheus datasource",
    tags=[
        'example'
    ],
    timezone="browser",
    panels=[
        TimeSeries(
            title="Random Walk",
            dataSource='default',
            targets=[
                Target(
                    datasource='grafana',
                    expr='example',
                ),
            ],
            gridPos=GridPos(h=8, w=16, x=0, y=0),
        ),
        GaugePanel(
            title="Random Walk",
            dataSource='default',
            targets=[
                Target(
                    datasource='grafana',
                    expr='example',
                ),
            ],
            gridPos=GridPos(h=4, w=4, x=17, y=0),
        ),
        TimeSeries(
            title="Prometheus http requests",
            dataSource='prometheus',
            targets=[
                Target(
                    expr='rate(prometheus_http_requests_total[5m])',
                    legendFormat="{{ handler }}",
                    refId='A',
                ),
            ],
            unit=OPS_FORMAT,
            gridPos=GridPos(h=8, w=16, x=0, y=10),
        ),
    ],
).auto_panel_ids()
```

--------------------------------

### Define alert groups and rules with AlertFileBasedProvisioning

Source: https://grafanalib.readthedocs.io/en/stable/getting-started.html

Use the AlertFileBasedProvisioning class to define alert groups and rules. Save this code in a file with the .alertfilebasedprovisioning.py extension.

```python
"""Example grafana 9.x+ Alert"""


from grafanalib.core import (
    AlertGroup,
    AlertRulev9,
    Target,
    AlertCondition,
    AlertExpression,
    AlertFileBasedProvisioning,
    GreaterThan,
    OP_AND,
    RTYPE_LAST,
    EXP_TYPE_CLASSIC,
    EXP_TYPE_REDUCE,
    EXP_TYPE_MATH
)

# An AlertGroup is one group contained in an alert folder.
alertgroup = AlertGroup(
    name="Production Alerts",
    # Each AlertRule forms a separate alert.
    rules=[
        # Alert rule using classic condition > 3
        AlertRulev9(
            # Each rule must have a unique title
            title="Alert for something 3",
            uid='alert3',
            # Several triggers can be used per alert
            condition='B',
            triggers=[
                # A target refId must be assigned, and exist only once per AlertRule.
                Target(
                    expr="from(bucket: \"sensors\")\n  |> range(start: v.timeRangeStart, stop: v.timeRangeStop)\n  |> filter(fn: (r) => r[\"_measurement\"] == \"remote_cpu\")\n  |> filter(fn: (r) => r[\"_field\"] == \"usage_system\")\n  |> filter(fn: (r) => r[\"cpu\"] == \"cpu-total\")\n  |> aggregateWindow(every: v.windowPeriod, fn: mean, createEmpty: false)\n  |> yield(name: \"mean\")",
                    # Set datasource to name of your datasource
                    datasource="influxdb",
                    refId="A",
                ),
                AlertExpression(
                    refId="B",
                    expressionType=EXP_TYPE_CLASSIC,
                    expression='A',
                    conditions=[
                        AlertCondition(
                            evaluator=GreaterThan(3),
                            operator=OP_AND,
                            reducerType=RTYPE_LAST
                        )
                    ]
                )
            ],
            annotations={
                "summary": "The database is down",
                "runbook_url": "runbook-for-this-scenario.com/foo",
            },
            labels={
                "environment": "prod",
                "slack": "prod-alerts",
            },
            evaluateFor="3m",
        ),
        # Alert rule using reduce and Math
        AlertRulev9(
            # Each rule must have a unique title
            title="Alert for something 4",
            uid='alert4',
            condition='C',
            # Several triggers can be used per alert
            triggers=[
                # A target refId must be assigned, and exist only once per AlertRule.
                Target(
                    expr="from(bucket: \"sensors\")\n  |> range(start: v.timeRangeStart, stop: v.timeRangeStop)\n  |> filter(fn: (r) => r[\"_measurement\"] == \"remote_cpu\")\n  |> filter(fn: (r) => r[\"_field\"] == \"usage_system\")\n  |> filter(fn: (r) => r[\"cpu\"] == \"cpu-total\")\n  |> aggregateWindow(every: v.windowPeriod, fn: mean, createEmpty: false)\n  |> yield(name: \"mean\")",
                    # Set datasource to name of your datasource
                    datasource="influxdb",
                    refId="A",
                ),
                AlertExpression(
                    refId="B",
                    expressionType=EXP_TYPE_REDUCE,
                    expression='A',
                    reduceFunction='mean',
                    reduceMode='dropNN'
                ),
                AlertExpression(
                    refId="C",
                    expressionType=EXP_TYPE_MATH,
                    expression='$B < 3'
                )
            ],
            annotations={
                "summary": "The database is down",
                "runbook_url": "runbook-for-this-scenario.com/foo",
            },
            labels={
                "environment": "prod",
                "slack": "prod-alerts",
            },
            evaluateFor="3m",
        )
    ]
)

alertfilebasedprovisioning = AlertFileBasedProvisioning([alertgroup])
```

--------------------------------

### zabbixServiceTarget()

Source: https://grafanalib.readthedocs.io/en/stable/api/modules.html

Creates a Zabbix service target for a Grafana dashboard panel.

```APIDOC
## zabbixServiceTarget()

### Description
Creates a Zabbix service target for a Grafana dashboard panel.
```

--------------------------------

### zabbixMetricTarget()

Source: https://grafanalib.readthedocs.io/en/stable/api/modules.html

Creates a Zabbix metric target for a Grafana dashboard panel.

```APIDOC
## zabbixMetricTarget()

### Description
Creates a Zabbix metric target for a Grafana dashboard panel.
```

--------------------------------

### Generate dashboard JSON via CLI

Source: https://grafanalib.readthedocs.io/en/stable/getting-started.html

Use the generate-dashboard command to convert a .dashboard.py file into a JSON dashboard file.

```bash
$ generate-dashboard -o frontend.json example.dashboard.py
```

--------------------------------

### Define Thresholds for Panels

Source: https://grafanalib.readthedocs.io/en/stable/api/grafanalib.html

Create a list of Threshold objects to define panel color changes. Ensure values are specified in increasing order as expected by Grafana.

```python
thresholds = [
    
Threshold(‘green’, 0, 0.0), Threshold(‘red’, 1, 80.0)]
```

--------------------------------

### zabbixTextTarget()

Source: https://grafanalib.readthedocs.io/en/stable/api/modules.html

Creates a Zabbix text target for a Grafana dashboard panel.

```APIDOC
## zabbixTextTarget()

### Description
Creates a Zabbix text target for a Grafana dashboard panel.
```

--------------------------------

### Define Graph Thresholds

Source: https://grafanalib.readthedocs.io/en/stable/api/grafanalib.html

Create a list of GraphThreshold objects to define visual thresholds for a graph panel.

```python
thresholds = [
    
GraphThreshold(colorMode=”ok”, value=10.0), GraphThreshold(colorMode=”critical”, value=90.0) ] 
```

--------------------------------

### Upload dashboards programmatically

Source: https://grafanalib.readthedocs.io/en/stable/getting-started.html

Use the provided functions to convert a Dashboard object to JSON and POST it to the Grafana API. Requires GRAFANA_API_KEY and GRAFANA_SERVER environment variables.

```python
from grafanalib.core import Dashboard
from grafanalib._gen import DashboardEncoder
import json
import requests
from os import getenv


def get_dashboard_json(dashboard, overwrite=False, message="Updated by grafanlib"):
    '''
    get_dashboard_json generates JSON from grafanalib Dashboard object

    :param dashboard - Dashboard() created via grafanalib
    '''

    # grafanalib generates json which need to pack to "dashboard" root element
    return json.dumps(
        {
            "dashboard": dashboard.to_json_data(),
            "overwrite": overwrite,
            "message": message
        }, sort_keys=True, indent=2, cls=DashboardEncoder)


def upload_to_grafana(json, server, api_key, verify=True):
    '''
    upload_to_grafana tries to upload dashboard to grafana and prints response

    :param json - dashboard json generated by grafanalib
    :param server - grafana server name
    :param api_key - grafana api key with read and write privileges
    '''

    headers = {'Authorization': f"Bearer {api_key}", 'Content-Type': 'application/json'}
    r = requests.post(f"https://{server}/api/dashboards/db", data=json, headers=headers, verify=verify)
    # TODO: add error handling
    print(f"{r.status_code} - {r.content}")


grafana_api_key = getenv("GRAFANA_API_KEY")
grafana_server = getenv("GRAFANA_SERVER")

my_dashboard = Dashboard(title="My awesome dashboard", uid='abifsd')
my_dashboard_json = get_dashboard_json(my_dashboard, overwrite=True)
upload_to_grafana(my_dashboard_json, grafana_server, grafana_api_key)
```

--------------------------------

### Generate Alert Group JSON

Source: https://grafanalib.readthedocs.io/en/stable/getting-started.html

Use the generate-alertgroup command-line tool to convert a .alertgroup.py file into a JSON representation.

```bash
$ generate-alertgroup -o alerts.json example.alertgroup.py
```

--------------------------------

### grafanalib.weave

Source: https://grafanalib.readthedocs.io/en/stable/api/grafanalib.html

Weave-specific dashboard configuration helpers.

```APIDOC
## grafanalib.weave.PercentUnitAxis(label=None)
A Y axis that shows a percentage based on a unit value.

## grafanalib.weave.QPSGraph(data_source, title, expressions, **kwargs)
Create a graph of QPS, broken up by response code using Prometheus data.

## grafanalib.weave.stacked(graph)
Turn a graph into a stacked graph.
```

--------------------------------

### Generate JSON alert file from Python script

Source: https://grafanalib.readthedocs.io/en/stable/getting-started.html

Use the generate-alertgroup command to convert your Python alert definition into a JSON file.

```bash
$ generate-alertgroup -o alerts.json example.alertfilebasedprovisioning.py
```

--------------------------------

### grafanalib.prometheus.PromGraph

Source: https://grafanalib.readthedocs.io/en/stable/api/grafanalib.html

Creates a graph that renders Prometheus data.

```APIDOC
## grafanalib.prometheus.PromGraph(data_source, title, expressions, **kwargs)

### Description
Create a graph that renders Prometheus data.

### Parameters
- **data_source** (str) - Required - The name of the data source that provides Prometheus data.
- **title** (any) - Required - The title of the graph.
- **expressions** (list) - Required - List of tuples of (legend, expr), where 'expr' is a Prometheus expression. Or a list of dict where keys are Target's args.
- **kwargs** (dict) - Optional - Passed on to Graph.
```

--------------------------------

### Configure Grafana v8+ Alerts

Source: https://grafanalib.readthedocs.io/en/stable/getting-started.html

Defines an AlertGroup containing multiple AlertRulev8 instances with specific triggers, annotations, and labels.

```python
"""Example grafana 8.x+ Alert"""


from grafanalib.core import (
    AlertGroup,
    AlertRulev8,
    Target,
    AlertCondition,
    LowerThan,
    OP_OR,
    OP_AND,
    RTYPE_LAST
)

# An AlertGroup is one group contained in an alert folder.
alertgroup = AlertGroup(
    name="Production Alerts",
    # Each AlertRule forms a separate alert.
    rules=[
        AlertRulev8(
            # Each rule must have a unique title
            title="Database is unresponsive",
            # Several triggers can be used per alert, a trigger is a combination of a Target and its AlertCondition in a tuple.
            triggers=[
                (
                    # A target refId must be assigned, and exist only once per AlertRule.
                    Target(
                        expr='sum(kube_pod_container_status_ready{exported_pod=~"database-/*"})',
                        # Set datasource to name of your datasource
                        datasource="VictoriaMetrics",
                        refId="A",
                    ),
                    AlertCondition(
                        evaluator=LowerThan(1),
                        # To have the alert fire when either of the triggers are met in the rule, set both AlertCondition operators to OP_OR.
                        operator=OP_OR,
                        reducerType=RTYPE_LAST
                    )
                ),
                (
                    Target(
                        expr='sum by (app) (count_over_time({app="database"}[5m]))',
                        # Set datasource to name of your datasource
                        datasource="Loki",
                        refId="B",
                    ),
                    AlertCondition(
                        evaluator=LowerThan(1000),
                        operator=OP_OR,
                        reducerType=RTYPE_LAST
                    )
                )
            ],
            annotations={
                "summary": "The database is down",
                "runbook_url": "runbook-for-this-scenario.com/foo",
            },
            labels={
                "environment": "prod",
                "slack": "prod-alerts",
            },
            evaluateInterval="1m",
            evaluateFor="3m",
        ),

        # Second alert
        AlertRulev8(
            title="Service API blackbox failure",
            triggers=[
                (
                    Target(
                        expr='probe_success{instance="my-service.foo.com/ready"}',
                        # Set datasource to name of your datasource
                        datasource="VictoriaMetrics",
                        refId="A",
                    ),
                    AlertCondition(
                        evaluator=LowerThan(1),
                        operator=OP_AND,
                        reducerType=RTYPE_LAST,
                    )
                )
            ],
            annotations={
                "summary": "Service API has been unavailable for 3 minutes",
                "runbook_url": "runbook-for-this-scenario.com/foo",
            },
            labels={
                "environment": "prod",
                "slack": "prod-alerts",
            },
            evaluateInterval="1m",
            evaluateFor="3m",
        )
    ]
)
```

--------------------------------

### grafanalib.core.Annotations

Source: https://grafanalib.readthedocs.io/en/stable/api/grafanalib.html

Represents a collection of annotations for Grafana dashboards or alerts.

```APIDOC
## class Annotations

### Description
Defines a collection of annotations.

### Parameters
- **list** (list) - Optional - A list of annotation items.

### Methods
- **to_json_data()** - Serializes the Annotations object to JSON format.
```

--------------------------------

### Define Grafana v9 Alert Groups and Rules

Source: https://grafanalib.readthedocs.io/en/stable/getting-started.html

Configures an AlertGroup containing multiple AlertRulev9 instances with different trigger types. Requires importing necessary classes from grafanalib.core.

```python
"""Example grafana 9.x+ Alert"""


from grafanalib.core import (
    AlertGroup,
    AlertRulev9,
    Target,
    AlertCondition,
    AlertExpression,
    GreaterThan,
    OP_AND,
    RTYPE_LAST,
    EXP_TYPE_CLASSIC,
    EXP_TYPE_REDUCE,
    EXP_TYPE_MATH
)

# An AlertGroup is one group contained in an alert folder.
alertgroup = AlertGroup(
    name="Production Alerts",
    # Each AlertRule forms a separate alert.
    rules=[
        # Alert rule using classic condition > 3
        AlertRulev9(
            # Each rule must have a unique title
            title="Alert for something 1",
            uid='alert1',
            # Several triggers can be used per alert
            condition='B',
            triggers=[
                # A target refId must be assigned, and exist only once per AlertRule.
                Target(
                    expr="from(bucket: \"sensors\")\n  |> range(start: v.timeRangeStart, stop: v.timeRangeStop)\n  |> filter(fn: (r) => r[\"_measurement\"] == \"remote_cpu\")\n  |> filter(fn: (r) => r[\"_field\"] == \"usage_system\")\n  |> filter(fn: (r) => r[\"cpu\"] == \"cpu-total\")\n  |> aggregateWindow(every: v.windowPeriod, fn: mean, createEmpty: false)\n  |> yield(name: \"mean\")",
                    # Set datasource to name of your datasource
                    datasource="influxdb",
                    refId="A",
                ),
                AlertExpression(
                    refId="B",
                    expressionType=EXP_TYPE_CLASSIC,
                    expression='A',
                    conditions=[
                        AlertCondition(
                            evaluator=GreaterThan(3),
                            operator=OP_AND,
                            reducerType=RTYPE_LAST
                        )
                    ]
                )
            ],
            annotations={
                "summary": "The database is down",
                "runbook_url": "runbook-for-this-scenario.com/foo",
            },
            labels={
                "environment": "prod",
                "slack": "prod-alerts",
            },
            evaluateFor="3m",
        ),
        # Alert rule using reduce and Math
        AlertRulev9(
            # Each rule must have a unique title
            title="Alert for something 2",
            uid='alert2',
            condition='C',
            # Several triggers can be used per alert
            triggers=[
                # A target refId must be assigned, and exist only once per AlertRule.
                Target(
                    expr="from(bucket: \"sensors\")\n  |> range(start: v.timeRangeStart, stop: v.timeRangeStop)\n  |> filter(fn: (r) => r[\"_measurement\"] == \"remote_cpu\")\n  |> filter(fn: (r) => r[\"_field\"] == \"usage_system\")\n  |> filter(fn: (r) => r[\"cpu\"] == \"cpu-total\")\n  |> aggregateWindow(every: v.windowPeriod, fn: mean, createEmpty: false)\n  |> yield(name: \"mean\")",
                    # Set datasource to name of your datasource
                    datasource="influxdb",
                    refId="A",
                ),
                AlertExpression(
                    refId="B",
                    expressionType=EXP_TYPE_REDUCE,
                    expression='A',
                    reduceFunction='mean',
                    reduceMode='dropNN'
                ),
                AlertExpression(
                    refId="C",
                    expressionType=EXP_TYPE_MATH,
                    expression='$B < 3'
                )
            ],
            annotations={
                "summary": "The database is down",
                "runbook_url": "runbook-for-this-scenario.com/foo",
            },
            labels={
                "environment": "prod",
                "slack": "prod-alerts",
            },
            evaluateFor="3m",
        )
    ]
)
```

--------------------------------

### CloudwatchMetricsTarget

Source: https://grafanalib.readthedocs.io/en/stable/api/grafanalib.html

Generates a Cloudwatch metrics target JSON structure for use in Grafana dashboards.

```APIDOC
## class CloudwatchMetricsTarget

### Description
Generates Cloudwatch target JSON structure.

### Parameters
- **alias** (str) - legend alias
- **dimensions** (dict) - Cloudwatch dimensions dict
- **expression** (str) - Cloudwatch Metric math expressions
- **id** (str) - unique id
- **matchExact** (bool) - Only show metrics that exactly match all defined dimension names.
- **metricName** (str) - Cloudwatch metric name
- **namespace** (str) - Cloudwatch namespace
- **period** (str) - Cloudwatch data period
- **refId** (str) - target reference id
- **region** (str) - Cloudwatch region
- **statistics** (list) - Cloudwatch mathematic statistics
- **statistic** (str) - Cloudwatch mathematic statistic
- **hide** (bool) - controls if given metric is displayed on visualization
- **datasource** (str) - Grafana datasource name

### Methods
- **to_json_data()**: Returns the JSON representation of the target.
```

--------------------------------

### convertZabbixSeverityColors()

Source: https://grafanalib.readthedocs.io/en/stable/api/modules.html

Converts Zabbix severity colors for use in Grafana dashboards.

```APIDOC
## convertZabbixSeverityColors()

### Description
Converts Zabbix severity colors for use in Grafana dashboards.
```

--------------------------------

### Upload Alert Group via REST API

Source: https://grafanalib.readthedocs.io/en/stable/getting-started.html

This script demonstrates how to serialize an AlertGroup object and upload it to Grafana. Note that the upload process deletes existing alerts in the specified group before replacing them.

```python
from grafanalib.core import AlertGroup
from grafanalib._gen import DashboardEncoder, loader
import json
import requests
from os import getenv


def get_alert_json(alert: AlertGroup):
    '''
    get_alert_json generates JSON from grafanalib AlertGroup object

    :param alert - AlertGroup created via grafanalib
    '''

    return json.dumps(alert.to_json_data(), sort_keys=True, indent=4, cls=DashboardEncoder)


def upload_to_grafana(alertjson, folder, server, api_key, session_cookie, verify=True):
    '''
    upload_to_grafana tries to upload the AlertGroup to grafana and prints response
    WARNING: This will first delete all alerts in the AlertGroup before replacing them with the provided AlertGroup.

    :param alertjson - AlertGroup json generated by grafanalib
    :param folder - Folder to upload the AlertGroup into
    :param server - grafana server name
    :param api_key - grafana api key with read and write privileges
    '''
    groupName = json.loads(alertjson)['name']

    headers = {}
    if api_key:
        print("using bearer auth")
        headers['Authorization'] = f"Bearer {api_key}"

    if session_cookie:
        print("using session cookie")
        headers['Cookie'] = session_cookie

    print(f"deleting AlertGroup {groupName} in folder {folder}")
    r = requests.delete(f"https://{server}/api/ruler/grafana/api/v1/rules/{folder}/{groupName}", headers=headers, verify=verify)
    print(f"{r.status_code} - {r.content}")

    headers['Content-Type'] = 'application/json'

    print(f"ensuring folder {folder} exists")
    r = requests.post(f"https://{server}/api/folders", data={"title": folder}, headers=headers)
    print(f"{r.status_code} - {r.content}")

    print(f"uploading AlertGroup {groupName} to folder {folder}")
    r = requests.post(f"https://{server}/api/ruler/grafana/api/v1/rules/{folder}", data=alertjson, headers=headers, verify=verify)
    # TODO: add error handling
    print(f"{r.status_code} - {r.content}")


grafana_api_key = getenv("GRAFANA_API_KEY")
grafana_server = getenv("GRAFANA_SERVER")
grafana_cookie = getenv("GRAFANA_COOKIE")

# Generate an alert from the example
my_alergroup_json = get_alert_json(loader("./grafanalib/tests/examples/example.alertgroup.py"))
upload_to_grafana(my_alergroup_json, "testfolder", grafana_server, grafana_api_key, grafana_cookie)
```

--------------------------------

### CloudwatchLogsInsightsTarget

Source: https://grafanalib.readthedocs.io/en/stable/api/grafanalib.html

Generates a Cloudwatch Logs Insights target JSON structure for use in Grafana dashboards.

```APIDOC
## class CloudwatchLogsInsightsTarget

### Description
Generates Cloudwatch Logs Insights target JSON structure.

### Parameters
- **expression** (str) - Cloudwatch Logs Insights expressions
- **id** (str) - unique id
- **logGroupNames** (list) - List of Cloudwatch log groups to query
- **namespace** (str) - Cloudwatch namespace
- **refId** (str) - target reference id
- **region** (str) - Cloudwatch region
- **statsGroups** (list) - Cloudwatch statsGroups
- **hide** (bool) - controls if given metric is displayed on visualization
- **datasource** (str) - Grafana datasource name

### Methods
- **to_json_data()**: Returns the JSON representation of the target.
```

--------------------------------

### grafanalib.core.BarChart

Source: https://grafanalib.readthedocs.io/en/stable/api/grafanalib.html

Represents a Bar Chart panel in Grafana. This class allows for the configuration of chart orientation, stacking, legend settings, and axis properties.

```APIDOC
## class grafanalib.core.BarChart

### Description
Generates the JSON structure for a Grafana Bar Chart panel.

### Parameters
- **orientation** (string) - Controls the orientation of the chart
- **xTickLabelRotation** (number) - Controls the rotation of bar labels
- **xTickLabelSpacing** (number) - Controls the spacing of bar labels
- **showValue** (string) - Controls the visibility of values
- **stacking** (string) - Controls the stacking of the bar chart
- **groupWidth** (number) - Controls the width of the group
- **barWidth** (number) - Controls the width of the bars
- **barRadius** (number) - Controls the radius of the bars
- **tooltipMode** (string) - Controls the style of tooltips
- **tooltipSort** (string) - Controls the sort order of tooltips
- **showLegend** (boolean) - Controls the visibility of legends
- **legendDisplayMode** (string) - Controls the style of legends
- **legendPlacement** (string) - Controls the placement of legends
- **legendCalcs** (list) - Controls the calculations to show on legends
- **lineWidth** (number) - Controls the width of lines
- **fillOpacity** (number) - Controls the opacity of bars
- **gradientMode** (string) - Controls the gradient style of the bars
- **axisPlacement** (string) - Controls the axis placement
- **axisLabel** (string) - Controls the axis labels
- **axisColorMode** (string) - Controls the axis color style
- **scaleDistributionType** (string) - Controls the type of distribution
- **axisCenteredZero** (boolean) - Controls the centering of the axis
- **hideFromTooltip** (boolean) - Controls the hiding of tooltips
- **hideFromViz** (boolean) - Controls the hiding of bars
- **hideFromLegend** (boolean) - Controls the hiding of legends
- **colorMode** (string) - Controls the color palette of the bars
- **fixedColor** (string) - Controls the color of the bars
- **mappings** (list) - Controls the mapping of values
- **thresholdsMode** (string) - Controls the style threshold
- **thresholdSteps** (list) - Controls the threshold steps
- **overrides** (list) - Controls the overriding of certain data base characteristics
```

--------------------------------

### grafanalib.opentsdb.OpenTSDBTarget

Source: https://grafanalib.readthedocs.io/en/stable/api/grafanalib.html

A class used to generate the JSON structure for an OpenTSDB data source target in Grafana.

```APIDOC
## class OpenTSDBTarget(metric, refId='', aggregator='sum', alias=None, isCounter=False, counterMax=None, counterResetValue=None, disableDownsampling=False, downsampleAggregator='sum', downsampleFillPolicy='none', downsampleInterval=None, filters=Nothing.NOTHING, shouldComputeRate=False, currentFilterGroupBy=False, currentFilterKey='', currentFilterType='literal_or', currentFilterValue='')

### Description
Generates the OpenTSDB target JSON structure for Grafana dashboards.

### Parameters
- **metric** (string) - Required - OpenTSDB metric name.
- **refId** (string) - Optional - Target reference ID.
- **aggregator** (string) - Optional - Defines metric aggregator.
- **alias** (string) - Optional - Legend alias.
- **isCounter** (boolean) - Optional - Defines if rate function results should be interpreted as a counter.
- **counterMax** (float) - Optional - Defines rate counter max value.
- **counterResetValue** (float) - Optional - Defines rate counter reset value.
- **disableDownsampling** (boolean) - Optional - Defines if downsampling should be disabled.
- **downsampleAggregator** (string) - Optional - Defines downsampling aggregator.
- **downsampleFillPolicy** (string) - Optional - Defines downsampling fill policy.
- **downsampleInterval** (string) - Optional - Defines downsampling interval.
- **filters** (list) - Optional - List of metric query filters.
- **shouldComputeRate** (boolean) - Optional - Defines if rate function should be used.

### Methods
- **to_json_data()**: Returns the JSON representation of the target.
```

--------------------------------

### grafanalib.core.AlertRulev9

Source: https://grafanalib.readthedocs.io/en/stable/api/grafanalib.html

Represents a Grafana 9.x+ Alert Rule. Users can instantiate this class to define alert rules with specific triggers, evaluation intervals, and state handling.

```APIDOC
## class AlertRulev9

### Description
Creates a Grafana 9.x+ Alert Rule object.

### Parameters
- **title** (string) - Required - The alert’s title, must be unique per folder.
- **triggers** (list) - Optional - A list of Targets and AlertConditions.
- **annotations** (dict) - Optional - Summary and annotations dictionary.
- **labels** (dict) - Optional - Custom labels for the metric.
- **condition** (string) - Optional - Set one of the queries or expressions as the alert condition by refID.
- **evaluateFor** (string) - Optional - The duration for which the condition must be true before an alert fires.
- **noDataAlertState** (string) - Optional - Alert state if no data or all values are null.
- **errorAlertState** (string) - Optional - Alert state if execution error or timeout.
- **timeRangeFrom** (int) - Optional - Time range interpolation data start from.
- **timeRangeTo** (int) - Optional - Time range interpolation data finish at.
- **uid** (string) - Optional - Alert UID.
- **dashboard_uid** (string) - Optional - Dashboard UID for linking.
- **panel_id** (int) - Optional - Panel ID for linking.

### Methods
- **to_json_data()** - Serializes the AlertRulev9 object to JSON format.
```

--------------------------------

### grafanalib.influxdb.InfluxDBTarget

Source: https://grafanalib.readthedocs.io/en/stable/api/grafanalib.html

A class used to generate the JSON structure for an InfluxDB data source target in Grafana.

```APIDOC
## class InfluxDBTarget(alias='', format='time_series', datasource='', measurement='', query='', rawQuery=True, refId='')

### Description
Generates the InfluxDB target JSON structure for Grafana dashboards.

### Parameters
- **alias** (string) - Optional - Legend alias.
- **format** (string) - Optional - Bucket aggregators.
- **datasource** (string) - Optional - InfluxDB name for multiple datasources.
- **measurement** (string) - Optional - Metric aggregators.
- **query** (string) - Optional - The InfluxDB query string.
- **rawQuery** (boolean) - Optional - Target reference ID.
- **refId** (string) - Optional - Target reference ID.

### Methods
- **to_json_data()**: Returns the JSON representation of the target.
```

--------------------------------

### grafanalib.elasticsearch.TermsGroupBy

Source: https://grafanalib.readthedocs.io/en/stable/api/grafanalib.html

A multi-bucket aggregator class based on field values for grouping data.

```APIDOC
## class TermsGroupBy(field, id=0, minDocCount=1, order='desc', orderBy='_term', size=0)

### Description
A multi-bucket aggregator based on field values.

### Parameters
- **id** (int) - Optional - Ascending unique number per GroupBy clause.
- **field** (string) - Required - Name of the field to group by.
- **minDocCount** (int) - Optional - Min. amount of matching records to return a result.
- **order** (string) - Optional - ORDER_ASC or ORDER_DESC.
- **orderBy** (string) - Optional - Term to order the bucket (e.g., '_term', '_count', or metric function string).
- **size** (int) - Optional - How many buckets are returned.
```

--------------------------------

### grafanalib.core.BarGauge

Source: https://grafanalib.readthedocs.io/en/stable/api/grafanalib.html

Represents a Bar Gauge panel in Grafana. This class allows for the configuration of gauge display modes, value formatting, and threshold markers.

```APIDOC
## class grafanalib.core.BarGauge

### Description
Generates the JSON structure for a Grafana Bar Gauge panel.
```

--------------------------------

### grafanalib.elasticsearch.SumMetricAgg

Source: https://grafanalib.readthedocs.io/en/stable/api/grafanalib.html

An aggregator class that provides the sum of values for a specified Elasticsearch field.

```APIDOC
## class SumMetricAgg(field='', id=0, hide=False, inline='')

### Description
An aggregator that provides the sum of the values from an Elasticsearch field.

### Parameters
- **field** (string) - Optional - Name of elasticsearch field to provide the sum over.
- **id** (int) - Optional - Unique identifier for the metric.
- **hide** (boolean) - Optional - Show/hide the metric in the final panel display.
- **inline** (string) - Optional - Script to apply to the data, using '_value'.
```

--------------------------------

### grafanalib.validators

Source: https://grafanalib.readthedocs.io/en/stable/api/grafanalib.html

Validator functions for attribute validation.

```APIDOC
## grafanalib.validators.is_color_code(instance, attribute, value)
Validates that a value is a valid color code starting with # followed by hexadecimal.

## grafanalib.validators.is_in(choices)
Validates that the attribute value is in a provided list of choices.

## grafanalib.validators.is_interval(instance, attribute, value)
Validates that the attribute value matches a regular expression for intervals.

## grafanalib.validators.is_list_of(etype)
Validates that the attribute value is a list of the specified type.
```
Tokens:
Raw