From 2ae19734a161a5b28878d269eeed5568edf45a3c Mon Sep 17 00:00:00 2001 From: Vu Anh Date: Mon, 22 Aug 2022 16:45:54 +0700 Subject: [PATCH 1/7] Add my info --- data/authors/vuanhbui.json | 7 +++++++ 1 file changed, 7 insertions(+) create mode 100644 data/authors/vuanhbui.json diff --git a/data/authors/vuanhbui.json b/data/authors/vuanhbui.json new file mode 100644 index 00000000..34225b33 --- /dev/null +++ b/data/authors/vuanhbui.json @@ -0,0 +1,7 @@ +{ + "name": "buivuanh", + "bio": "", + "social": { + "github": "https://github.com/buivuanh" + } +} \ No newline at end of file From 0746585a1fb8da3224b4424a239395b08448b620 Mon Sep 17 00:00:00 2001 From: Vu Anh Date: Mon, 22 Aug 2022 16:46:13 +0700 Subject: [PATCH 2/7] Add my first blog --- .../index.md | 393 ++++++++++++++++++ 1 file changed, 393 insertions(+) create mode 100644 content/posts/build-a-grafana-dashboard-generator/index.md diff --git a/content/posts/build-a-grafana-dashboard-generator/index.md b/content/posts/build-a-grafana-dashboard-generator/index.md new file mode 100644 index 00000000..e94261ca --- /dev/null +++ b/content/posts/build-a-grafana-dashboard-generator/index.md @@ -0,0 +1,393 @@ ++++ +title: "Build a Grafana dashboard using Grafonnet" +date: 2022-08-22T16:19:32+07:00 +author = "buivuanh" +description = "This tutorial helps you build Grafana dashboard config by using Grafonnet and golang." +categories = ["Monitoring", "Automation"] +tags = ["Grafana", "configure-Grafana-as-code", "Grafonnet"] +slug = "build-a-grafana-dashboard-using-grafonnet" ++++ + +## Overview + +- Currently, if we want to create a Grafana dashboard, we often use UI and copy json config into our repo. +- And We have to manager folder which contains dashboard configs JSON files. + +=> Maintain a set of dashboards for people with conflicting preferences and goals. Or you’re dealing with confusion +because one graph shows errors in one color and a new one uses a different color. Or there’s a new feature in Grafana +and you need to change 50 dashboards to use it. As a result, making sure your dashboards work and look good is no longer +a simple process. + +=> That’s why we want to use your dashboard as code. + +## [Jsonnet](https://github.com/google/go-jsonnet) + +A data templating language for app and tool developers + +- Generate config data +- Side-effect free +- Organize, simplify, unify +- Manage sprawling config + +The example: + +- You define a local variable and then that same local variable is referenced later: + +``` +local greeting = "hello world!"; + +{ + foo: "bar", + dict: { + nested: greeting + }, +} +``` + +=> + +``` +{ + "foo": "bar", + "dict": { + "nested": "hello world!" + } +} +``` + +- Or, use functions: + +``` +// A function that returns an object. +local Person(name='Alice') = { + name: name, + welcome: 'Hello ' + name + '!', +}; +{ + person1: Person(), + person2: Person('Bob'), +} +``` + +=> + +``` +{ + "person1": { + "name": "Alice", + "welcome": "Hello Alice!" + }, + "person2": { + "name": "Bob", + "welcome": "Hello Bob!" + } +} +``` + +- Patches: You call your Jsonnet function and append to it the snippet of JSON, and it simply adds — overwrites: like + so: + +``` +dashboard: { + new(title, uid): {...} +} + +dashboard.new(...) + { + schemaVersion: 22, +} +``` + +=> + +``` +{ + "title": "super dash", + "uid": "my-dash", + "Panels": [], + "schemaVersion": 22 +} +``` + +- Imports: Not only can you create functions, but you also can put those functions into files. + +``` +{ + alertlist:: import 'alertlist.libsonnet', + dashboard:: import 'dashboard.libsonnet', + gauge:: error 'gauge is removed, migrate to gaugePanel', + gaugePanel:: import 'gauge_panel.libsonnet', +} +``` + +## [Grafonnet](https://github.com/grafana/grafonnet-lib) + +- Is a very simple library that provides you with the basics: creating a dashboard, creating a panel, creating a single + stat panel, and so on. +- See more examples: https://github.com/grafana/grafonnet-lib/tree/master/examples +- E.g: we have one `dashboard.jsonnet` jsonnet file, maybe call it is main file which will evaluates it to json file + +``` +local grafana = import 'grafonnet/grafana.libsonnet'; +local dashboard = grafana.dashboard; +local annotation = grafana.annotation; +local template = grafana.template; +local graphPanel = grafana.graphPanel; +local prometheus = grafana.prometheus; + +dashboard.new( + 'title', + editable=true, + refresh='5s', + time_from='now-6h', + time_to='now', + timepicker={}, + schemaVersion=27, + uid='uid', +) +.addAnnotation(annotation.default) +.addTemplate( + template.datasource( + name='cluster', + query='prometheus', + current='Thanos', + hide='', + ) +) +.addTemplate( + template.new( + name='namespace', + datasource='${cluster}', + query={ + query: 'label_values(grpc_io_server_completed_rpcs, namespace)', + refId: 'StandardVariableQuery' + }, + label='Namespace', + hide='', + refresh='load', + definition='label_values(grpc_io_server_completed_rpcs, namespace)' + ) +) +.addPanel( + graphPanel.new( + title='Number of requests', + datasource='${cluster}', + fill=1, + legend_show=true, + lines=true, + linewidth=1, + pointradius=2, + stack=true, + shared_tooltip=true, + value_type='individual', + ).resetYaxes(). + addYaxis( + format='none', + ).addYaxis( + format='short', + ).addTarget( + prometheus.custom_target( + expr='expr', + legendFormat='legendFormat', + ) + ), gridPos={ + x: 0, + y: 1, + w: 18, + h: 10, + } +) +``` + +- And now, we are going to make config from above jsonnet file. + +``` +func MakeConfig() error { + vm := jsonnet.MakeVM() + jsonData, err := vm.EvaluateFile(`dashboard.jsonnet`) + if err != nil { + return err + } + fmt.Println(jsonData) + return nil +} +``` + +- Result will look like: + +``` +{ + "__inputs": [ ], + "__requires": [ ], + "annotations": { + "list": [ + { + "builtIn": 1, + "datasource": "-- Grafana --", + "enable": true, + "hide": true, + "iconColor": "rgba(0, 211, 255, 1)", + "name": "Annotations & Alerts", + "type": "dashboard" + } + ] + }, + "editable": true, + "gnetId": null, + "graphTooltip": 0, + "hideControls": false, + "id": null, + "links": [ ], + "panels": [ + { + "aliasColors": { }, + "bars": false, + "dashLength": 10, + "dashes": false, + "datasource": "${cluster}", + "fill": 1, + "fillGradient": 0, + "gridPos": { + "h": 10, + "w": 18, + "x": 0, + "y": 1 + }, + "hiddenSeries": false, + "id": 2, + "legend": { + "alignAsTable": false, + "avg": false, + "current": false, + "max": false, + "min": false, + "rightSide": false, + "show": true, + "sideWidth": null, + "total": false, + "values": false + }, + "lines": true, + "linewidth": 1, + "links": [ ], + "nullPointMode": "null", + "percentage": false, + "pointradius": 2, + "points": false, + "renderer": "flot", + "repeat": null, + "seriesOverrides": [ ], + "spaceLength": 10, + "stack": true, + "steppedLine": false, + "targets": [ + { + "expr": "expr", + "legendFormat": "legendFormat", + "refId": "A" + } + ], + "thresholds": [ ], + "timeFrom": null, + "timeShift": null, + "title": "Number of requests", + "tooltip": { + "shared": true, + "sort": 0, + "value_type": "individual" + }, + "type": "graph", + "xaxis": { + "buckets": null, + "mode": "time", + "name": null, + "show": true, + "values": [ ] + }, + "yaxes": [ + { + "format": "none", + "label": null, + "logBase": 1, + "max": null, + "min": null, + "show": true + }, + { + "format": "short", + "label": null, + "logBase": 1, + "max": null, + "min": null, + "show": true + } + ], + "yaxis": { + "align": false, + "alignLevel": null + } + } + ], + "refresh": "5s", + "rows": [ ], + "schemaVersion": 27, + "style": "dark", + "tags": [ ], + "templating": { + "list": [ + { + "current": { + "text": "Thanos", + "value": "Thanos" + }, + "hide": 0, + "label": null, + "name": "cluster", + "options": [ ], + "query": "prometheus", + "refresh": 1, + "regex": "", + "type": "datasource" + }, + { + "allValue": null, + "current": { }, + "datasource": "${cluster}", + "definition": "label_values(grpc_io_server_completed_rpcs, namespace)", + "hide": 0, + "includeAll": false, + "label": "Namespace", + "multi": false, + "name": "namespace", + "options": [ ], + "query": { + "query": "label_values(grpc_io_server_completed_rpcs, namespace)", + "refId": "StandardVariableQuery" + }, + "refresh": 1, + "regex": "", + "sort": 0, + "tagValuesQuery": "", + "tags": [ ], + "tagsQuery": "", + "type": "query", + "useTags": false + } + ] + }, + "time": { + "from": "now-6h", + "to": "now" + }, + "timepicker": { }, + "timezone": "browser", + "title": "title", + "uid": "uid", + "version": 0 +} +``` + +## More +When you are able to config dashboard as code, in particular: using golang to make config base Grafonnet lib, you can totally add more feature such as : +- Create and manage dashboard config files with jsonnet format instead of raw json files. +- Can reuse one or more pannels for multiple dashboards. +- Build jsonnet template file which you can fill automatically params such metric names, grpc methods .... \ No newline at end of file From ba99c2e57027ade08e1d73fc2536ca5079490ba9 Mon Sep 17 00:00:00 2001 From: Vu Anh Date: Mon, 22 Aug 2022 16:46:24 +0700 Subject: [PATCH 3/7] Add example --- .../examples/dashboard.jsonnet | 69 ++++ .../examples/go.mod | 15 + .../examples/go.sum | 31 ++ .../examples/grafonnet/annotation.libsonnet | 40 ++ .../examples/grafonnet/dashboard.libsonnet | 181 +++++++++ .../examples/grafonnet/grafana.libsonnet | 7 + .../examples/grafonnet/graph_panel.libsonnet | 344 ++++++++++++++++++ .../examples/grafonnet/prometheus.libsonnet | 58 +++ .../examples/grafonnet/template.libsonnet | 291 +++++++++++++++ .../examples/main.go | 17 + .../examples/main_test.go | 12 + 11 files changed, 1065 insertions(+) create mode 100644 content/posts/build-a-grafana-dashboard-generator/examples/dashboard.jsonnet create mode 100644 content/posts/build-a-grafana-dashboard-generator/examples/go.mod create mode 100644 content/posts/build-a-grafana-dashboard-generator/examples/go.sum create mode 100644 content/posts/build-a-grafana-dashboard-generator/examples/grafonnet/annotation.libsonnet create mode 100644 content/posts/build-a-grafana-dashboard-generator/examples/grafonnet/dashboard.libsonnet create mode 100644 content/posts/build-a-grafana-dashboard-generator/examples/grafonnet/grafana.libsonnet create mode 100644 content/posts/build-a-grafana-dashboard-generator/examples/grafonnet/graph_panel.libsonnet create mode 100644 content/posts/build-a-grafana-dashboard-generator/examples/grafonnet/prometheus.libsonnet create mode 100644 content/posts/build-a-grafana-dashboard-generator/examples/grafonnet/template.libsonnet create mode 100644 content/posts/build-a-grafana-dashboard-generator/examples/main.go create mode 100644 content/posts/build-a-grafana-dashboard-generator/examples/main_test.go diff --git a/content/posts/build-a-grafana-dashboard-generator/examples/dashboard.jsonnet b/content/posts/build-a-grafana-dashboard-generator/examples/dashboard.jsonnet new file mode 100644 index 00000000..c6e2e6d3 --- /dev/null +++ b/content/posts/build-a-grafana-dashboard-generator/examples/dashboard.jsonnet @@ -0,0 +1,69 @@ +local grafana = import 'grafonnet/grafana.libsonnet'; +local dashboard = grafana.dashboard; +local annotation = grafana.annotation; +local template = grafana.template; +local graphPanel = grafana.graphPanel; +local prometheus = grafana.prometheus; + +dashboard.new( + 'title', + editable=true, + refresh='5s', + time_from='now-6h', + time_to='now', + timepicker={}, + schemaVersion=27, + uid='uid', +) +.addAnnotation(annotation.default) +.addTemplate( + template.datasource( + name='cluster', + query='prometheus', + current='Thanos', + hide='', + ) +) +.addTemplate( + template.new( + name='namespace', + datasource='${cluster}', + query={ + query: 'label_values(grpc_io_server_completed_rpcs, namespace)', + refId: 'StandardVariableQuery' + }, + label='Namespace', + hide='', + refresh='load', + definition='label_values(grpc_io_server_completed_rpcs, namespace)' + ) +) +.addPanel( + graphPanel.new( + title='Number of requests', + datasource='${cluster}', + fill=1, + legend_show=true, + lines=true, + linewidth=1, + pointradius=2, + stack=true, + shared_tooltip=true, + value_type='individual', + ).resetYaxes(). + addYaxis( + format='none', + ).addYaxis( + format='short', + ).addTarget( + prometheus.custom_target( + expr='expr', + legendFormat='legendFormat', + ) + ), gridPos={ + x: 0, + y: 1, + w: 18, + h: 10, + } +) \ No newline at end of file diff --git a/content/posts/build-a-grafana-dashboard-generator/examples/go.mod b/content/posts/build-a-grafana-dashboard-generator/examples/go.mod new file mode 100644 index 00000000..b065ca48 --- /dev/null +++ b/content/posts/build-a-grafana-dashboard-generator/examples/go.mod @@ -0,0 +1,15 @@ +module github.com/manabie-com/manabie-com.github.io/content/posts/build-a-grafana-dashboard-generator/examples + +go 1.18 + +require ( + github.com/google/go-jsonnet v0.18.0 + github.com/stretchr/testify v1.4.0 +) + +require ( + github.com/davecgh/go-spew v1.1.1 // indirect + github.com/pmezard/go-difflib v1.0.0 // indirect + gopkg.in/yaml.v2 v2.2.7 // indirect + sigs.k8s.io/yaml v1.1.0 // indirect +) diff --git a/content/posts/build-a-grafana-dashboard-generator/examples/go.sum b/content/posts/build-a-grafana-dashboard-generator/examples/go.sum new file mode 100644 index 00000000..824546c8 --- /dev/null +++ b/content/posts/build-a-grafana-dashboard-generator/examples/go.sum @@ -0,0 +1,31 @@ +github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/fatih/color v1.10.0/go.mod h1:ELkj/draVOlAH/xkhN6mQ50Qd0MPOk5AAr3maGEBuJM= +github.com/google/go-jsonnet v0.18.0 h1:/6pTy6g+Jh1a1I2UMoAODkqELFiVIdOxbNwv0DDzoOg= +github.com/google/go-jsonnet v0.18.0/go.mod h1:C3fTzyVJDslXdiTqw/bTFk7vSGyCtH3MGRbDfvEwGd0= +github.com/kr/pretty v0.1.0 h1:L/CwN0zerZDmRFUapSPitk6f+Q3+0za1rQkzVuMiMFI= +github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo= +github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= +github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE= +github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= +github.com/mattn/go-colorable v0.1.8/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc= +github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU= +github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/sergi/go-diff v1.1.0 h1:we8PVUC3FE2uYfodKH/nBHMSetSfHDR6scGdBi+erh0= +github.com/sergi/go-diff v1.1.0/go.mod h1:STckp+ISIX8hZLjrqAeVduY0gWCT9IjLuqbuNXdaHfM= +github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= +github.com/stretchr/testify v1.4.0 h1:2E4SXV/wtOkTonXsotYi4li6zVWxYlZuYNCXe9XRJyk= +github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4= +golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15 h1:YR8cESwS4TdDjEe65xsg0ogRM/Nc3DYOhEAlW+xobZo= +gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v2 v2.2.7 h1:VUgggvou5XRW9mHwD/yXxIYSMtY0zoKQf/v226p2nyo= +gopkg.in/yaml.v2 v2.2.7/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +sigs.k8s.io/yaml v1.1.0 h1:4A07+ZFc2wgJwo8YNlQpr1rVlgUDlxXHhPJciaPY5gs= +sigs.k8s.io/yaml v1.1.0/go.mod h1:UJmg0vDUVViEyp3mgSv9WPwZCDxu4rQW1olrI1uml+o= diff --git a/content/posts/build-a-grafana-dashboard-generator/examples/grafonnet/annotation.libsonnet b/content/posts/build-a-grafana-dashboard-generator/examples/grafonnet/annotation.libsonnet new file mode 100644 index 00000000..955b029c --- /dev/null +++ b/content/posts/build-a-grafana-dashboard-generator/examples/grafonnet/annotation.libsonnet @@ -0,0 +1,40 @@ +{ + default:: + { + builtIn: 1, + datasource: '-- Grafana --', + enable: true, + hide: true, + iconColor: 'rgba(0, 211, 255, 1)', + name: 'Annotations & Alerts', + type: 'dashboard', + }, + + /** + * @name annotation.datasource + */ + + datasource( + name, + datasource, + expr=null, + enable=true, + hide=false, + iconColor='rgba(255, 96, 96, 1)', + tags=[], + type='tags', + builtIn=null, + ):: + { + datasource: datasource, + enable: enable, + [if expr != null then 'expr']: expr, + hide: hide, + iconColor: iconColor, + name: name, + showIn: 0, + tags: tags, + type: type, + [if builtIn != null then 'builtIn']: builtIn, + }, +} diff --git a/content/posts/build-a-grafana-dashboard-generator/examples/grafonnet/dashboard.libsonnet b/content/posts/build-a-grafana-dashboard-generator/examples/grafonnet/dashboard.libsonnet new file mode 100644 index 00000000..1cc1bf32 --- /dev/null +++ b/content/posts/build-a-grafana-dashboard-generator/examples/grafonnet/dashboard.libsonnet @@ -0,0 +1,181 @@ +local timepickerlib = import 'timepicker.libsonnet'; + +{ + /** + * Creates a [dashboard](https://grafana.com/docs/grafana/latest/features/dashboard/dashboards/) + * + * @name dashboard.new + * + * @param title The title of the dashboard + * @param editable (default: `false`) Whether the dashboard is editable via Grafana UI. + * @param style (default: `'dark'`) Theme of dashboard, `'dark'` or `'light'` + * @param tags (optional) Array of tags associated to the dashboard, e.g.`['tag1','tag2']` + * @param time_from (default: `'now-6h'`) + * @param time_to (default: `'now'`) + * @param timezone (default: `'browser'`) Timezone of the dashboard, `'utc'` or `'browser'` + * @param refresh (default: `''`) Auto-refresh interval, e.g. `'30s'` + * @param timepicker (optional) See timepicker API + * @param graphTooltip (default: `'default'`) `'default'` : no shared crosshair or tooltip (0), `'shared_crosshair'`: shared crosshair (1), `'shared_tooltip'`: shared crosshair AND shared tooltip (2) + * @param hideControls (default: `false`) + * @param schemaVersion (default: `14`) Version of the Grafana JSON schema, incremented each time an update brings changes. `26` for Grafana 7.1.5, `22` for Grafana 6.7.4, `16` for Grafana 5.4.5, `14` for Grafana 4.6.3. etc. + * @param uid (default: `''`) Unique dashboard identifier as a string (8-40), that can be chosen by users. Used to identify a dashboard to update when using Grafana REST API. + * @param description (optional) + * + * @method addTemplate(template) Add a template variable + * @method addTemplates(templates) Adds an array of template variables + * @method addAnnotation(annotation) Add an [annotation](https://grafana.com/docs/grafana/latest/dashboards/annotations/) + * @method addPanel(panel,gridPos) Appends a panel, with an optional grid position in grid coordinates, e.g. `gridPos={'x':0, 'y':0, 'w':12, 'h': 9}` + * @method addPanels(panels) Appends an array of panels + * @method addLink(link) Adds a [dashboard link](https://grafana.com/docs/grafana/latest/linking/dashboard-links/) + * @method addLinks(dashboardLink) Adds an array of [dashboard links](https://grafana.com/docs/grafana/latest/linking/dashboard-links/) + * @method addRequired(type, name, id, version) + * @method addInput(name, label, type, pluginId, pluginName, description, value) + * @method addRow(row) Adds a row. This is the legacy row concept from Grafana < 5, when rows were needed for layout. Rows should now be added via `addPanel`. + */ + new( + title, + editable=false, + style='dark', + tags=[], + time_from='now-6h', + time_to='now', + timezone='browser', + refresh='', + timepicker=timepickerlib.new(), + graphTooltip='default', + hideControls=false, + schemaVersion=14, + uid='', + description=null, + ):: { + local it = self, + _annotations:: [], + [if uid != '' then 'uid']: uid, + editable: editable, + [if description != null then 'description']: description, + gnetId: null, + graphTooltip: + if graphTooltip == 'shared_tooltip' then 2 + else if graphTooltip == 'shared_crosshair' then 1 + else if graphTooltip == 'default' then 0 + else graphTooltip, + hideControls: hideControls, + id: null, + links: [], + panels:: [], + refresh: refresh, + rows: [], + schemaVersion: schemaVersion, + style: style, + tags: tags, + time: { + from: time_from, + to: time_to, + }, + timezone: timezone, + timepicker: timepicker, + title: title, + version: 0, + addAnnotations(annotations):: self { + _annotations+:: annotations, + }, + addAnnotation(a):: self.addAnnotations([a]), + addTemplates(templates):: self { + templates+: templates, + }, + addTemplate(t):: self.addTemplates([t]), + templates:: [], + annotations: { list: it._annotations }, + templating: { list: it.templates }, + _nextPanel:: 2, + addRow(row):: + self { + // automatically number panels in added rows. + // https://github.com/kausalco/public/blob/master/klumps/grafana.libsonnet + local n = std.length(row.panels), + local nextPanel = super._nextPanel, + local panels = std.makeArray(n, function(i) + row.panels[i] { id: nextPanel + i }), + + _nextPanel: nextPanel + n, + rows+: [row { panels: panels }], + }, + addPanels(newpanels):: + self { + // automatically number panels in added rows. + // https://github.com/kausalco/public/blob/master/klumps/grafana.libsonnet + local n = std.foldl(function(numOfPanels, p) + (if 'panels' in p then + numOfPanels + 1 + std.length(p.panels) + else + numOfPanels + 1), newpanels, 0), + local nextPanel = super._nextPanel, + local _panels = std.makeArray( + std.length(newpanels), function(i) + newpanels[i] { + id: nextPanel + ( + if i == 0 then + 0 + else + if 'panels' in _panels[i - 1] then + (_panels[i - 1].id - nextPanel) + 1 + std.length(_panels[i - 1].panels) + else + (_panels[i - 1].id - nextPanel) + 1 + + ), + [if 'panels' in newpanels[i] then 'panels']: std.makeArray( + std.length(newpanels[i].panels), function(j) + newpanels[i].panels[j] { + id: 1 + j + + nextPanel + ( + if i == 0 then + 0 + else + if 'panels' in _panels[i - 1] then + (_panels[i - 1].id - nextPanel) + 1 + std.length(_panels[i - 1].panels) + else + (_panels[i - 1].id - nextPanel) + 1 + + ), + } + ), + } + ), + + _nextPanel: nextPanel + n, + panels+::: _panels, + }, + addPanel(panel, gridPos):: self.addPanels([panel { gridPos: gridPos }]), + addRows(rows):: std.foldl(function(d, row) d.addRow(row), rows, self), + addLink(link):: self { + links+: [link], + }, + addLinks(dashboardLinks):: std.foldl(function(d, t) d.addLink(t), dashboardLinks, self), + required:: [], + __requires: it.required, + addRequired(type, name, id, version):: self { + required+: [{ type: type, name: name, id: id, version: version }], + }, + inputs:: [], + __inputs: it.inputs, + addInput( + name, + label, + type, + pluginId=null, + pluginName=null, + description='', + value=null, + ):: self { + inputs+: [{ + name: name, + label: label, + type: type, + [if pluginId != null then 'pluginId']: pluginId, + [if pluginName != null then 'pluginName']: pluginName, + [if value != null then 'value']: value, + description: description, + }], + }, + }, +} diff --git a/content/posts/build-a-grafana-dashboard-generator/examples/grafonnet/grafana.libsonnet b/content/posts/build-a-grafana-dashboard-generator/examples/grafonnet/grafana.libsonnet new file mode 100644 index 00000000..7b1ac1cd --- /dev/null +++ b/content/posts/build-a-grafana-dashboard-generator/examples/grafonnet/grafana.libsonnet @@ -0,0 +1,7 @@ +{ + dashboard:: import 'dashboard.libsonnet', + template:: import 'template.libsonnet', + annotation:: import 'annotation.libsonnet', + graphPanel:: import 'graph_panel.libsonnet', + prometheus:: import 'prometheus.libsonnet', +} diff --git a/content/posts/build-a-grafana-dashboard-generator/examples/grafonnet/graph_panel.libsonnet b/content/posts/build-a-grafana-dashboard-generator/examples/grafonnet/graph_panel.libsonnet new file mode 100644 index 00000000..c501ce9e --- /dev/null +++ b/content/posts/build-a-grafana-dashboard-generator/examples/grafonnet/graph_panel.libsonnet @@ -0,0 +1,344 @@ +{ + /** + * Creates a [graph panel](https://grafana.com/docs/grafana/latest/panels/visualizations/graph-panel/). + * It requires the graph panel plugin in grafana, which is built-in. + * + * @name graphPanel.new + * + * @param title The title of the graph panel. + * @param description (optional) The description of the panel + * @param span (optional) Width of the panel + * @param datasource (optional) Datasource + * @param fill (default `1`) , integer from 0 to 10 + * @param fillGradient (default `0`) , integer from 0 to 10 + * @param linewidth (default `1`) Line Width, integer from 0 to 10 + * @param decimals (optional) Override automatic decimal precision for legend and tooltip. If null, not added to the json output. + * @param decimalsY1 (optional) Override automatic decimal precision for the first Y axis. If null, use decimals parameter. + * @param decimalsY2 (optional) Override automatic decimal precision for the second Y axis. If null, use decimals parameter. + * @param min_span (optional) Min span + * @param format (default `short`) Unit of the Y axes + * @param formatY1 (optional) Unit of the first Y axis + * @param formatY2 (optional) Unit of the second Y axis + * @param min (optional) Min of the Y axes + * @param max (optional) Max of the Y axes + * @param maxDataPoints (optional) If the data source supports it, sets the maximum number of data points for each series returned. + * @param labelY1 (optional) Label of the first Y axis + * @param labelY2 (optional) Label of the second Y axis + * @param x_axis_mode (default `'time'`) X axis mode, one of [time, series, histogram] + * @param x_axis_values (default `'total'`) Chosen value of series, one of [avg, min, max, total, count] + * @param x_axis_buckets (optional) Restricts the x axis to this amount of buckets + * @param x_axis_min (optional) Restricts the x axis to display from this value if supplied + * @param x_axis_max (optional) Restricts the x axis to display up to this value if supplied + * @param lines (default `true`) Display lines + * @param points (default `false`) Display points + * @param pointradius (default `5`) Radius of the points, allowed values are 0.5 or [1 ... 10] with step 1 + * @param bars (default `false`) Display bars + * @param staircase (default `false`) Display line as staircase + * @param dashes (default `false`) Display line as dashes + * @param stack (default `false`) Whether to stack values + * @param repeat (optional) Name of variable that should be used to repeat this panel. + * @param repeatDirection (default `'h'`) 'h' for horizontal or 'v' for vertical. + * @param legend_show (default `true`) Show legend + * @param legend_values (default `false`) Show values in legend + * @param legend_min (default `false`) Show min in legend + * @param legend_max (default `false`) Show max in legend + * @param legend_current (default `false`) Show current in legend + * @param legend_total (default `false`) Show total in legend + * @param legend_avg (default `false`) Show average in legend + * @param legend_alignAsTable (default `false`) Show legend as table + * @param legend_rightSide (default `false`) Show legend to the right + * @param legend_sideWidth (optional) Legend width + * @param legend_sort (optional) Sort order of legend + * @param legend_sortDesc (optional) Sort legend descending + * @param aliasColors (optional) Define color mappings for graphs + * @param thresholds (optional) An array of graph thresholds + * @param logBase1Y (default `1`) Value of logarithm base of the first Y axis + * @param logBase2Y (default `1`) Value of logarithm base of the second Y axis + * @param transparent (default `false`) Whether to display the panel without a background. + * @param value_type (default `'individual'`) Type of tooltip value + * @param shared_tooltip (default `true`) Allow to group or spit tooltips on mouseover within a chart + * @param percentage (defaut: false) show as percentages + * @param interval (defaut: null) A lower limit for the interval. + + * + * @method addTarget(target) Adds a target object. + * @method addTargets(targets) Adds an array of targets. + * @method addSeriesOverride(override) + * @method addYaxis(format,min,max,label,show,logBase,decimals) Adds a Y axis to the graph + * @method addAlert(alert) Adds an alert + * @method addLink(link) Adds a [panel link](https://grafana.com/docs/grafana/latest/linking/panel-links/) + * @method addLinks(links) Adds an array of links. + */ + new( + title, + span=null, + fill=1, + fillGradient=0, + linewidth=1, + decimals=null, + decimalsY1=null, + decimalsY2=null, + description=null, + min_span=null, + format='short', + formatY1=null, + formatY2=null, + min=null, + max=null, + labelY1=null, + labelY2=null, + x_axis_mode='time', + x_axis_values='total', + x_axis_buckets=null, + x_axis_min=null, + x_axis_max=null, + lines=true, + datasource=null, + points=false, + pointradius=5, + bars=false, + staircase=false, + height=null, + nullPointMode='null', + dashes=false, + stack=false, + repeat=null, + repeatDirection=null, + sort=0, + show_xaxis=true, + legend_show=true, + legend_values=false, + legend_min=false, + legend_max=false, + legend_current=false, + legend_total=false, + legend_avg=false, + legend_alignAsTable=false, + legend_rightSide=false, + legend_sideWidth=null, + legend_hideEmpty=null, + legend_hideZero=null, + legend_sort=null, + legend_sortDesc=null, + aliasColors={}, + thresholds=[], + links=[], + logBase1Y=1, + logBase2Y=1, + transparent=false, + value_type='individual', + shared_tooltip=true, + percentage=false, + maxDataPoints=null, + time_from=null, + time_shift=null, + interval=null, + hiddenSeries=false, + unit=null, + ):: { + title: title, + [if span != null then 'span']: span, + [if min_span != null then 'minSpan']: min_span, + [if decimals != null then 'decimals']: decimals, + type: 'graph', + datasource: datasource, + targets: [ + ], + [if description != null then 'description']: description, + [if height != null then 'height']: height, + renderer: 'flot', + yaxes: [ + self.yaxe( + if formatY1 != null then formatY1 else format, + min, + max, + decimals=(if decimalsY1 != null then decimalsY1 else decimals), + logBase=logBase1Y, + label=labelY1 + ), + self.yaxe( + if formatY2 != null then formatY2 else format, + min, + max, + decimals=(if decimalsY2 != null then decimalsY2 else decimals), + logBase=logBase2Y, + label=labelY2 + ), + ], + xaxis: { + show: show_xaxis, + mode: x_axis_mode, + name: null, + values: if x_axis_mode == 'series' then [x_axis_values] else [], + buckets: if x_axis_mode == 'histogram' then x_axis_buckets else null, + [if x_axis_min != null then 'min']: x_axis_min, + [if x_axis_max != null then 'max']: x_axis_max, + }, + lines: lines, + fill: fill, + fillGradient: fillGradient, + linewidth: linewidth, + dashes: dashes, + dashLength: 10, + spaceLength: 10, + points: points, + pointradius: pointradius, + bars: bars, + stack: stack, + percentage: percentage, + [if maxDataPoints != null then 'maxDataPoints']: maxDataPoints, + legend: { + show: legend_show, + values: legend_values, + min: legend_min, + max: legend_max, + current: legend_current, + total: legend_total, + alignAsTable: legend_alignAsTable, + rightSide: legend_rightSide, + sideWidth: legend_sideWidth, + avg: legend_avg, + [if legend_hideEmpty != null then 'hideEmpty']: legend_hideEmpty, + [if legend_hideZero != null then 'hideZero']: legend_hideZero, + [if legend_sort != null then 'sort']: legend_sort, + [if legend_sortDesc != null then 'sortDesc']: legend_sortDesc, + }, + nullPointMode: nullPointMode, + steppedLine: staircase, + tooltip: { + value_type: value_type, + shared: shared_tooltip, + sort: if sort == 'decreasing' then 2 else if sort == 'increasing' then 1 else sort, + }, + timeFrom: time_from, + timeShift: time_shift, + [if interval != null then 'interval']: interval, + [if transparent == true then 'transparent']: transparent, + aliasColors: aliasColors, + repeat: repeat, + [if repeatDirection != null then 'repeatDirection']: repeatDirection, + seriesOverrides: [], + thresholds: thresholds, + links: links, + hiddenSeries: hiddenSeries, + yaxis: { + align: false, + alignLevel: null + }, + yaxe( + format='short', + min=null, + max=null, + label=null, + show=true, + logBase=1, + decimals=null, + ):: { + label: label, + show: show, + logBase: logBase, + min: min, + max: max, + format: format, + [if decimals != null then 'decimals']: decimals, + }, + _nextTarget:: 0, + [if unit != null then 'fieldConfig']: { + defaults: { + unit: unit + }, + }, + addTarget(target):: self { + // automatically ref id in added targets. + // https://github.com/kausalco/public/blob/master/klumps/grafana.libsonnet + local nextTarget = super._nextTarget, + _nextTarget: nextTarget + 1, + targets+: [target { refId: std.char(std.codepoint('A') + nextTarget) }], + }, + addTargets(targets):: std.foldl(function(p, t) p.addTarget(t), targets, self), + addSeriesOverride(override):: self { + seriesOverrides+: [override], + }, + resetYaxes():: self { + yaxes: [], + }, + addYaxis( + format='short', + min=null, + max=null, + label=null, + show=true, + logBase=1, + decimals=null, + ):: self { + yaxes+: [self.yaxe(format, min, max, label, show, logBase, decimals)], + }, + addAlert( + name, + executionErrorState='alerting', + forDuration='5m', + frequency='60s', + handler=1, + message='', + noDataState='no_data', + notifications=[], + alertRuleTags={}, + ):: self { + local it = self, + _conditions:: [], + alert: { + name: name, + conditions: it._conditions, + executionErrorState: executionErrorState, + 'for': forDuration, + frequency: frequency, + handler: handler, + noDataState: noDataState, + notifications: notifications, + message: message, + alertRuleTags: alertRuleTags, + }, + addCondition(condition):: self { + _conditions+: [condition], + }, + addConditions(conditions):: std.foldl(function(p, c) p.addCondition(c), conditions, it), + }, + addLink(link):: self { + links+: [link], + }, + addLinks(links):: std.foldl(function(p, t) p.addLink(t), links, self), + addOverride( + matcher=null, + properties=null, + ):: self { + fieldConfig+: { + overrides+: [ + { + [if matcher != null then 'matcher']: matcher, + [if properties != null then 'properties']: properties, + }, + ], + }, + }, + addOverrides(overrides):: std.foldl(function(p, o) p.addOverride(o.matcher, o.properties), overrides, self), + addThreshold( + mode = 'absolute', + step, + ):: self { + fieldConfig+: { + defaults+: { + steps+: [step] + }, + }, + }, + addFieldConfigColorMode( + color_mode = 'thresholds' + ):: self { + fieldConfig+: { + color: { + mode: color_mode + }, + }, + }, + }, +} diff --git a/content/posts/build-a-grafana-dashboard-generator/examples/grafonnet/prometheus.libsonnet b/content/posts/build-a-grafana-dashboard-generator/examples/grafonnet/prometheus.libsonnet new file mode 100644 index 00000000..b4945acd --- /dev/null +++ b/content/posts/build-a-grafana-dashboard-generator/examples/grafonnet/prometheus.libsonnet @@ -0,0 +1,58 @@ +{ + /** + * Creates a [Prometheus target](https://grafana.com/docs/grafana/latest/datasources/prometheus/) + * to be added to panels. + * + * @name prometheus.target + * + * @param expr PromQL query to be exercised against Prometheus. Checkout [Prometheus documentation](https://prometheus.io/docs/prometheus/latest/querying/basics/). + * @param format (default `'time_series'`) Switch between `'table'`, `'time_series'` or `'heatmap'`. Table will only work in the Table panel. Heatmap is suitable for displaying metrics of the Histogram type on a Heatmap panel. Under the hood, it converts cumulative histograms to regular ones and sorts series by the bucket bound. + * @param intervalFactor (default `2`) + * @param legendFormat (default `''`) Controls the name of the time series, using name or pattern. For example `{{hostname}}` is replaced with the label value for the label `hostname`. + * @param datasource (optional) Name of the Prometheus datasource. Leave by default otherwise. + * @param interval (optional) Time span used to aggregate or group data points by time. By default Grafana uses an automatic interval calculated based on the width of the graph. + * @param instant (optional) Perform an "instant" query, to return only the latest value that Prometheus has scraped for the requested time series. Instant queries return results much faster than normal range queries. Use them to look up label sets. + * @param hide (optional) Set to `true` to hide the target from the panel. + * + * @return A Prometheus target to be added to panels. + */ + target( + expr, + format='time_series', + intervalFactor=2, + legendFormat='', + datasource=null, + interval=null, + instant=null, + hide=null, + ):: { + [if hide != null then 'hide']: hide, + [if datasource != null then 'datasource']: datasource, + expr: expr, + format: format, + intervalFactor: intervalFactor, + legendFormat: legendFormat, + [if interval != null then 'interval']: interval, + [if instant != null then 'instant']: instant, + }, + custom_target( + expr='', + format=null, + intervalFactor=null, + legendFormat='', + datasource=null, + interval=null, + instant=null, + hide=null, + exemplar=true, + ):: { + [if hide != null then 'hide']: hide, + [if datasource != null then 'datasource']: datasource, + expr: expr, + [if format != null then 'format']: format, + [if intervalFactor != null then 'intervalFactor']: intervalFactor, + legendFormat: legendFormat, + [if interval != null then 'interval']: interval, + [if instant != null then 'instant']: instant, + }, +} diff --git a/content/posts/build-a-grafana-dashboard-generator/examples/grafonnet/template.libsonnet b/content/posts/build-a-grafana-dashboard-generator/examples/grafonnet/template.libsonnet new file mode 100644 index 00000000..1e0900f9 --- /dev/null +++ b/content/posts/build-a-grafana-dashboard-generator/examples/grafonnet/template.libsonnet @@ -0,0 +1,291 @@ +{ + /** + * Creates a [template](https://grafana.com/docs/grafana/latest/variables/#templates) that can be added to a dashboard. + * + * @name template.new + * + * @param name Name of variable. + * @param datasource Template [datasource](https://grafana.com/docs/grafana/latest/variables/variable-types/add-data-source-variable/) + * @param query [Query expression](https://grafana.com/docs/grafana/latest/variables/variable-types/add-query-variable/) for the datasource. + * @param label (optional) Display name of the variable dropdown. If null, then the dropdown label will be the variable name. + * @param allValues (optional) Formatting for [multi-value variables](https://grafana.com/docs/grafana/latest/variables/formatting-multi-value-variables/#formatting-multi-value-variables) + * @param tagValuesQuery (default `''`) Group values into [selectable tags](https://grafana.com/docs/grafana/latest/variables/variable-value-tags/) + * @param current (default `null`) Can be `null`, `'all'` for all, or any other custom text value. + * @param hide (default `''`) `''`: the variable dropdown displays the variable Name or Label value. `'label'`: the variable dropdown only displays the selected variable value and a down arrow. Any other value: no variable dropdown is displayed on the dashboard. + * @param regex (default `''`) Regex expression to filter or capture specific parts of the names returned by your data source query. To see examples, refer to [Filter variables with regex](https://grafana.com/docs/grafana/latest/variables/filter-variables-with-regex/). + * @param refresh (default `'never'`) `'never'`: variables queries are cached and values are not updated. This is fine if the values never change, but problematic if they are dynamic and change a lot. `'load'`: Queries the data source every time the dashboard loads. This slows down dashboard loading, because the variable query needs to be completed before dashboard can be initialized. `'time'`: Queries the data source when the dashboard time range changes. Only use this option if your variable options query contains a time range filter or is dependent on the dashboard time range. + * @param includeAll (default `false`) Whether all value option is available or not. + * @param multi (default `false`) Whether multiple values can be selected or not from variable value list. + * @param sort (default `0`) `0`: Without Sort, `1`: Alphabetical (asc), `2`: Alphabetical (desc), `3`: Numerical (asc), `4`: Numerical (desc). + * + * @return A [template](https://grafana.com/docs/grafana/latest/variables/#templates) + */ + new( + name, + datasource, + query, + label=null, + allValues=null, + tagValuesQuery='', + current=null, + hide='', + regex='', + refresh='never', + includeAll=false, + multi=false, + sort=0, + definition, + ):: + { + allValue: allValues, + current: $.current(current), + datasource: datasource, + includeAll: includeAll, + hide: $.hide(hide), + label: label, + multi: multi, + name: name, + options: [], + query: query, + refresh: $.refresh(refresh), + regex: regex, + sort: sort, + tagValuesQuery: tagValuesQuery, + tags: [], + tagsQuery: '', + type: 'query', + useTags: false, + definition: definition, + }, + /** + * Use an [interval variable](https://grafana.com/docs/grafana/latest/variables/variable-types/add-interval-variable/) to represent time spans such as '1m', '1h', '1d'. You can think of them as a dashboard-wide "group by time" command. Interval variables change how the data is grouped in the visualization. You can also use the Auto Option to return a set number of data points per time span. + * You can use an interval variable as a parameter to group by time (for InfluxDB), date histogram interval (for Elasticsearch), or as a summarize function parameter (for Graphite). + * + * @name template.interval + * + * @param name Variable name + * @param query Comma separated values without spacing of intervals available for selection. Add `'auto'` in the query to turn on the Auto Option. Ex: `'auto,5m,10m,20m'`. + * @param current Currently selected interval. Must be one of the values in the query. `'auto'` is allowed if defined in the query. + * @param hide (default `''`) `''`: the variable dropdown displays the variable Name or Label value. `'label'`: the variable dropdown only displays the selected variable value and a down arrow. Any other value: no variable dropdown is displayed on the dashboard. + * @param label (optional) Display name of the variable dropdown. If null, then the dropdown label will be the variable name. + * @param auto_count (default `300`) Valid only if `'auto'` is defined in query. Number of times the current time range will be divided to calculate the value, similar to the Max data points query option. For example, if the current visible time range is 30 minutes, then the auto interval groups the data into 30 one-minute increments. The default value is 30 steps. + * @param auto_min (default `'10s'`) Valid only if `'auto'` is defined in query. The minimum threshold below which the step count intervals will not divide the time. To continue the 30 minute example, if the minimum interval is set to `'2m'`, then Grafana would group the data into 15 two-minute increments. + * + * @return A new interval variable for templating. + */ + interval( + name, + query, + current, + hide='', + label=null, + auto_count=300, + auto_min='10s', + ):: + { + current: $.current(current), + hide: $.hide(hide), + label: label, + name: name, + query: std.join(',', std.filter($.filterAuto, std.split(query, ','))), + refresh: 2, + type: 'interval', + auto: std.count(std.split(query, ','), 'auto') > 0, + auto_count: auto_count, + auto_min: auto_min, + }, + hide(hide):: + if hide == '' then 0 else if hide == 'label' then 1 else 2, + current(current):: { + [if current != null then 'text']: current, + [if current != null then 'value']: if current == 'auto' then + '$__auto_interval' + else if current == 'all' then + '$__all' + else + current, + }, + /** + * Data [source variables](https://grafana.com/docs/grafana/latest/variables/variable-types/add-data-source-variable/) + * allow you to quickly change the data source for an entire dashboard. + * They are useful if you have multiple instances of a data source, perhaps in different environments. + * + * @name template.datasource + * + * @param name Data source variable name. Ex: `'PROMETHEUS_DS'`. + * @param query Type of data source. Ex: `'prometheus'`. + * @param current Ex: `'Prometheus'`. + * @param hide (default `''`) `''`: the variable dropdown displays the variable Name or Label value. `'label'`: the variable dropdown only displays the selected variable value and a down arrow. Any other value: no variable dropdown is displayed on the dashboard. + * @param label (optional) Display name of the variable dropdown. If null, then the dropdown label will be the variable name. + * @param regex (default `''`) Regex filter for which data source instances to choose from in the variable value drop-down list. Leave this field empty to display all instances. + * @param refresh (default `'load'`) `'never'`: Variables queries are cached and values are not updated. This is fine if the values never change, but problematic if they are dynamic and change a lot. `'load'`: Queries the data source every time the dashboard loads. This slows down dashboard loading, because the variable query needs to be completed before dashboard can be initialized. `'time'`: Queries the data source when the dashboard time range changes. Only use this option if your variable options query contains a time range filter or is dependent on the dashboard time range. + * + * @return A [data source variable](https://grafana.com/docs/grafana/latest/variables/variable-types/add-data-source-variable/). + */ + datasource( + name, + query, + current, + hide='', + label=null, + regex='', + refresh='load', + ):: { + current: $.current(current), + hide: $.hide(hide), + label: label, + name: name, + options: [], + query: query, + refresh: $.refresh(refresh), + regex: regex, + type: 'datasource', + }, + refresh(refresh):: if refresh == 'never' + then + 0 + else if refresh == 'load' + then + 1 + else if refresh == 'time' + then + 2 + else + refresh, + filterAuto(str):: str != 'auto', + /** + * Use a [custom variable](https://grafana.com/docs/grafana/latest/variables/variable-types/add-custom-variable/) + * for values that do not change. + * + * @name template.custom + * This might be numbers, strings, or even other variables. + * @param name Variable name + * @param query Comma separated without spacing list of selectable values. + * @param current Selected value + * @param refresh (default `'never'`) `'never'`: Variables queries are cached and values are not updated. This is fine if the values never change, but problematic if they are dynamic and change a lot. `'load'`: Queries the data source every time the dashboard loads. This slows down dashboard loading, because the variable query needs to be completed before dashboard can be initialized. `'time'`: Queries the data source when the dashboard time range changes. Only use this option if your variable options query contains a time range filter or is dependent on the dashboard time range. + * @param label (default `''`) Display name of the variable dropdown. If you don’t enter a display name, then the dropdown label will be the variable name. + * @param valuelabels (default `{}`) Display names for values defined in query. For example, if `query='new,old'`, then you may display them as follows `valuelabels={new: 'nouveau', old: 'ancien'}`. + * @param multi (default `false`) Whether multiple values can be selected or not from variable value list. + * @param allValues (optional) Formatting for [multi-value variables](https://grafana.com/docs/grafana/latest/variables/formatting-multi-value-variables/#formatting-multi-value-variables) + * @param includeAll (default `false`) Whether all value option is available or not. + * @param hide (default `''`) `''`: the variable dropdown displays the variable Name or Label value. `'label'`: the variable dropdown only displays the selected variable value and a down arrow. Any other value: no variable dropdown is displayed on the dashboard. + * + * @return A custom variable. + */ + custom( + name, + query, + current, + refresh='never', + label='', + valuelabels={}, + multi=false, + allValues=null, + includeAll=false, + hide='', + ):: + { + // self has dynamic scope, so self may not be myself below. + // '$' can't be used neither as this object is not top-level object. + local custom = self, + + allValue: allValues, + current: { + // Both 'all' and 'All' are accepted for consistency. + value: if includeAll && (current == 'All' || current == 'all') then + if multi then ['$__all'] else '$__all' + else + current, + text: if std.isArray(current) then + std.join(' + ', std.map(custom.valuelabel, current)) + else + custom.valuelabel(current), + [if multi then 'selected']: true, + }, + options: std.map(self.option, self.query_array(query)), + hide: $.hide(hide), + includeAll: includeAll, + label: label, + refresh: $.refresh(refresh), + multi: multi, + name: name, + query: query, + type: 'custom', + + valuelabel(value):: if value in valuelabels then + valuelabels[value] + else value, + + option(option):: { + text: custom.valuelabel(option), + value: if includeAll && option == 'All' then '$__all' else option, + [if multi then 'selected']: if multi && std.isArray(current) then + std.member(current, option) + else if multi then + current == option + else + null, + }, + query_array(query):: std.split( + if includeAll then 'All,' + query else query, ',' + ), + }, + /** + * [Text box variables](https://grafana.com/docs/grafana/latest/variables/variable-types/add-text-box-variable/) + * display a free text input field with an optional default value. + * This is the most flexible variable, because you can enter any value. + * Use this type of variable if you have metrics with high cardinality or if you want to + * update multiple panels in a dashboard at the same time. + * + * @name template.text + * + * @param name Variable name. + * @param label (default `''`) Display name of the variable dropdown. If you don’t enter a display name, then the dropdown label will be the variable name. + * + * @return A text box variable. + */ + text( + name, + label='' + ):: + { + current: { + selected: false, + text: '', + value: '', + }, + name: name, + label: label, + query: '', + type: 'textbox', + }, + /** + * [Ad hoc filters](https://grafana.com/docs/grafana/latest/variables/variable-types/add-ad-hoc-filters/) + * allow you to add key/value filters that are automatically added to all metric queries + * that use the specified data source. Unlike other variables, you do not use ad hoc filters in queries. + * Instead, you use ad hoc filters to write filters for existing queries. + * Note: Ad hoc filter variables only work with InfluxDB, Prometheus, and Elasticsearch data sources. + * + * @name template.adhoc + * + * @param name Variable name. + * @param datasource Target data source + * @param label (optional) Display name of the variable dropdown. If you don’t enter a display name, then the dropdown label will be the variable name. + * @param hide (default `''`) `''`: the variable dropdown displays the variable Name or Label value. `'label'`: the variable dropdown only displays the selected variable value and a down arrow. Any other value: no variable dropdown is displayed on the dashboard. + * + * @return An ad hoc filter + */ + adhoc( + name, + datasource, + label=null, + hide='', + ):: + { + datasource: datasource, + hide: $.hide(hide), + label: label, + name: name, + type: 'adhoc', + }, +} diff --git a/content/posts/build-a-grafana-dashboard-generator/examples/main.go b/content/posts/build-a-grafana-dashboard-generator/examples/main.go new file mode 100644 index 00000000..6070ee5d --- /dev/null +++ b/content/posts/build-a-grafana-dashboard-generator/examples/main.go @@ -0,0 +1,17 @@ +package examples + +import ( + "fmt" + + "github.com/google/go-jsonnet" +) + +func MakeConfig() error { + vm := jsonnet.MakeVM() + jsonData, err := vm.EvaluateFile(`dashboard.jsonnet`) + if err != nil { + return err + } + fmt.Println(jsonData) + return nil +} diff --git a/content/posts/build-a-grafana-dashboard-generator/examples/main_test.go b/content/posts/build-a-grafana-dashboard-generator/examples/main_test.go new file mode 100644 index 00000000..2530b74f --- /dev/null +++ b/content/posts/build-a-grafana-dashboard-generator/examples/main_test.go @@ -0,0 +1,12 @@ +package examples + +import ( + "testing" + + "github.com/stretchr/testify/require" +) + +func TestMakeConfig(t *testing.T) { + err := MakeConfig() + require.NoError(t, err) +} From 25898b21add0ce93402c075874c774f70aa545aa Mon Sep 17 00:00:00 2001 From: Vu Anh Date: Mon, 22 Aug 2022 17:15:47 +0700 Subject: [PATCH 4/7] Add project structure --- .../posts/build-a-grafana-dashboard-generator/index.md | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/content/posts/build-a-grafana-dashboard-generator/index.md b/content/posts/build-a-grafana-dashboard-generator/index.md index e94261ca..5286cd29 100644 --- a/content/posts/build-a-grafana-dashboard-generator/index.md +++ b/content/posts/build-a-grafana-dashboard-generator/index.md @@ -386,6 +386,14 @@ func MakeConfig() error { } ``` +- Project's structure will look like: +``` +my-repo/ +├─ grafonnet/ +├─ dashboard.jsonnet +├─ main.go +``` + ## More When you are able to config dashboard as code, in particular: using golang to make config base Grafonnet lib, you can totally add more feature such as : - Create and manage dashboard config files with jsonnet format instead of raw json files. From cb5125bf9117bcc3e3c8649dfde4058559e8fe94 Mon Sep 17 00:00:00 2001 From: Vu Anh Date: Mon, 22 Aug 2022 17:29:11 +0700 Subject: [PATCH 5/7] Fix syntax issue --- content/posts/build-a-grafana-dashboard-generator/index.md | 4 ++-- data/authors/{vuanhbui.json => buivuanh.json} | 0 2 files changed, 2 insertions(+), 2 deletions(-) rename data/authors/{vuanhbui.json => buivuanh.json} (100%) diff --git a/content/posts/build-a-grafana-dashboard-generator/index.md b/content/posts/build-a-grafana-dashboard-generator/index.md index 5286cd29..d9a6ba38 100644 --- a/content/posts/build-a-grafana-dashboard-generator/index.md +++ b/content/posts/build-a-grafana-dashboard-generator/index.md @@ -1,6 +1,6 @@ +++ -title: "Build a Grafana dashboard using Grafonnet" -date: 2022-08-22T16:19:32+07:00 +title = "Build a Grafana dashboard using Grafonnet" +date = "2022-08-22T16:19:32+07:00" author = "buivuanh" description = "This tutorial helps you build Grafana dashboard config by using Grafonnet and golang." categories = ["Monitoring", "Automation"] diff --git a/data/authors/vuanhbui.json b/data/authors/buivuanh.json similarity index 100% rename from data/authors/vuanhbui.json rename to data/authors/buivuanh.json From 81fe1cdf2a167abd1fabbd04f75b651b5d480d92 Mon Sep 17 00:00:00 2001 From: Vu Anh Date: Tue, 23 Aug 2022 10:03:57 +0700 Subject: [PATCH 6/7] Add a Grafana UI image --- .../graph.png | Bin 0 -> 156968 bytes .../index.md | 4 +++- 2 files changed, 3 insertions(+), 1 deletion(-) create mode 100644 content/posts/build-a-grafana-dashboard-generator/graph.png diff --git a/content/posts/build-a-grafana-dashboard-generator/graph.png b/content/posts/build-a-grafana-dashboard-generator/graph.png new file mode 100644 index 0000000000000000000000000000000000000000..8b8c92a752be79cebee22f69c6ede797888ef7b3 GIT binary patch literal 156968 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 VGv!;N5sb*%Fl8pPdqkam-!U37=TsAz(J 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≈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 Date: Thu, 25 Aug 2022 13:50:00 +0700 Subject: [PATCH 7/7] Fix gramar --- content/posts/build-a-grafana-dashboard-generator/index.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/content/posts/build-a-grafana-dashboard-generator/index.md b/content/posts/build-a-grafana-dashboard-generator/index.md index a3698629..14d228c9 100644 --- a/content/posts/build-a-grafana-dashboard-generator/index.md +++ b/content/posts/build-a-grafana-dashboard-generator/index.md @@ -11,7 +11,7 @@ slug = "build-a-grafana-dashboard-using-grafonnet" ## Overview - Currently, if we want to create a Grafana dashboard, we often use UI and copy json config into our repo. -- And We have to manager folder which contains dashboard configs JSON files. +- And We have to manage folder which contains dashboard configs JSON files. => Maintain a set of dashboards for people with conflicting preferences and goals. Or you’re dealing with confusion because one graph shows errors in one color and a new one uses a different color. Or there’s a new feature in Grafana