Add initial structure for windows modular mixin

windows-mixin/dashboards/dashboards.libsonnet

@@ -1,2 +1,12 @@
-(import 'windows_exporter.libsonnet') +
-(import 'windows_logs.libsonnet')
+// (import 'windows_exporter.libsonnet') +
+// (import 'windows_logs.libsonnet')
+local winlib = import '../lib/windows-lib/main.libsonnet';
+{
+    local windows = winlib.new(
+        prefix="My ",
+        uid="windows",
+        filterSelector='job="windows"',
+    ),
+    grafanaDashboards+:: 
+        windows.dashboards
+}

windows-mixin/jsonnetfile.json

@@ -9,6 +9,14 @@
         }
       },
       "version": "master"
+    },
+    {
+      "source": {
+        "local": {
+          "directory": "lib/windows-lib"
+        }
+      },
+      "version": ""
     }
   ],
   "legacyImports": true

windows-mixin/lib/windows-lib/dashboards.libsonnet

@@ -0,0 +1,34 @@
+local g = import './g.libsonnet';
+
+{
+    local this = self,
+    new(
+        prefix,
+        links,
+        tags,
+        uid,
+        vars):
+    {
+        fleet: 
+            local title=prefix+"Windows fleet overview";
+            g.dashboard.new(title)
+            // hide link to self
+            + this.applyCommon(vars.multiInstance, uid+'-fleet', tags, links + { backToFleet+:: {}, backToOverview+:: {} }),
+        overview: g.dashboard.new(prefix+"Windows overview")
+            + g.dashboard.withUid('overview')
+            + this.applyCommon(vars.singleInstance, uid+'-overview', tags, links + { backToOverview+:: {} }),
+        network: g.dashboard.new(prefix+"Windows network")
+            + this.applyCommon(vars.singleInstance, uid+'-network', tags, links),
+
+        disks: g.dashboard.new(prefix+"Windows disks and filesystems")
+            + this.applyCommon(vars.singleInstance, uid+'-disks', tags, links),
+
+        logs: g.dashboard.new(prefix+"Windows logs")
+            + this.applyCommon(vars.multiInstance, uid+'-logs', tags, links),
+    },
+    applyCommon(vars, uid, tags, links):
+        g.dashboard.withTags(tags)
+        + g.dashboard.withUid(g.util.string.slugify(uid))
+        + g.dashboard.withLinks(std.objectValues(links))
+        + g.dashboard.withVariables(vars)
+}

windows-mixin/lib/windows-lib/g.libsonnet

@@ -0,0 +1 @@
+import 'github.com/grafana/grafonnet/gen/grafonnet-v10.0.0/main.libsonnet'

windows-mixin/lib/windows-lib/jsonnetfile.json

@@ -0,0 +1,23 @@
+{
+  "version": 1,
+  "dependencies": [
+    {
+      "source": {
+        "local": {
+          "directory": "../../../../jl-common-lib/common-lib/common"
+        }
+      },
+      "version": ""
+    },
+    {
+      "source": {
+        "git": {
+          "remote": "https://github.com/grafana/grafonnet.git",
+          "subdir": "gen/grafonnet-v10.0.0"
+        }
+      },
+      "version": "main"
+    }
+  ],
+  "legacyImports": true
+}

windows-mixin/lib/windows-lib/main.libsonnet

@@ -0,0 +1,92 @@
+local dashboards = import './dashboards.libsonnet';
+local panels = import './panels.libsonnet';
+local targets = import './targets.libsonnet';
+local variables = import './variables.libsonnet';
+local g = import './g.libsonnet';
+local commonlib = import 'common/main.libsonnet';
+
+{
+
+  // any modular library should inlcude as inputs:
+  // 'prefix' - Use as prefix for all Dashboards and (optional) rule groups
+  // 'filterSelector' - Static selector to apply to ALL dashboard variables of type query, panel queries, alerts and recording rules.
+  // 'groupLabels' - one or more labels that can be used to identify 'group' of instances. In simple cases, can be 'job' or 'cluster'.
+  // 'instanceLabels' - one or more labels that can be used to identify single entity of instances. In simple cases, can be 'instance' or 'pod'.
+
+  new(
+    prefix="",
+    filterSelector,
+    tags=[uid],
+    uid,
+    // filterSelector,
+    groupLabels=['job'],
+    instanceLabels=['instance']
+    // datasourceRegex,
+    // datasourceName='datasource',
+    // formatParser=null,
+    // showLogsVolume=true,
+    // logsVolumeGroupBy='level',
+    // extraFilters='',
+  ): {
+
+    local this = self,
+    variables: variables.new(
+    //   datasourceName,
+    //   datasourceRegex,
+      filterSelector,
+      groupLabels,
+      instanceLabels,
+    ),
+
+    // targets: targets.new(
+    //   this.variables,
+    // //   formatParser,
+    // //   logsVolumeGroupBy,
+    // //   extraFilters,
+    // ),
+    // annotations: {
+    //   reboot: commonlib.annotations.reboot.new(
+    //   title="Reboot",
+    //   target=c.commonPromTarget(
+    //     'windows_system_system_up_time{%(nodeQuerySelector)s}*1000 > $__from < $__to' % config { nodeQuerySelector: nodeQuerySelector },
+    //     legendFormat='',
+    //   ),
+    //   instanceLabels="instance",
+    // ),
+    // },
+
+    // common links here
+    links: {
+      local link = g.dashboard.link,
+      backToFleet:
+        link.link.new('Back to Windows fleet', "/d/" + this.dashboards.fleet.uid)
+        + link.link.options.withKeepTime(true),
+      backToOverview:
+        link.link.new('Back to Windows overview', "/d/" + this.dashboards.overview.uid)
+        + link.link.options.withKeepTime(true),
+      otherDashboards:  
+        link.dashboards.new('All Windows dashboards', tags)
+        + link.dashboards.options.withIncludeVars(true)
+        + link.dashboards.options.withKeepTime(true)
+        + link.dashboards.options.withAsDropdown(true),
+    },
+
+    panels: panels.new(
+    //   this.targets.logsVolumeTarget,
+    //   this.targets.logsTarget,
+    ),
+
+    dashboards: dashboards.new(
+      prefix,
+      this.links,
+      tags,
+      uid,
+      // this.panels,
+      this.variables,
+    ),
+
+    alerts: {},
+    recordingRules: {},
+  },
+
+}

windows-mixin/lib/windows-lib/utils.libsonnet

@@ -0,0 +1,38 @@
+{
+  local this = self,
+
+  labelsToURLvars(labels, prefix)::
+    std.join('&', ['var-%s=${%s%s}' % [label, prefix, label] for label in labels]),
+
+  // For PromQL or LogQL
+  labelsToPromQLSelector(labels): std.join(',', ['%s=~"$%s"' % [label, label] for label in labels]),
+  labelsToLogQLSelector: self.labelsToPromQLSelector,
+
+  labelsToPanelLegend(labels): std.join('/', ['{{%s}}' % [label] for label in labels]),
+
+  // Generate a chain of labels. Useful to create chained variables
+  chainLabels(labels, additionalFilters=[]):
+    local last(arr) = std.reverse(arr)[0];
+    local chainSelector(chain) =
+      std.join(
+        ',',
+        additionalFilters
+        + (if std.length(chain) > 0
+           then [this.labelsToPromQLSelector(chain)]
+           else [])
+      );
+    std.foldl(
+      function(prev, label)
+        prev
+        + [{
+          label: label,
+          chainSelector: chainSelector(self.chain),
+          chain::
+            if std.length(prev) > 0
+            then last(prev).chain + [last(prev).label]
+            else [],
+        }],
+      labels,
+      []
+    ),
+}

windows-mixin/lib/windows-lib/variables.libsonnet

@@ -0,0 +1,57 @@
+// variables.libsonnet
+local g = import './g.libsonnet';
+local var = g.dashboard.variable;
+local utils = import './utils.libsonnet';
+
+{
+    new(
+        filterSelector,
+        groupLabels,
+        instanceLabels,
+        ): {
+
+        local this = self,
+        local varMetric = 'windows_os_info',
+        local variablesFromLabels(groupLabels, instanceLabels, filterSelector, multiInstance=true) =
+            local chainVarProto(index, chainVar) =
+                var.query.new(chainVar.label)
+                + var.query.withDatasourceFromVariable(this.datasource)
+                + var.query.queryTypes.withLabelValues(
+                chainVar.label,
+                '%s{%s}' % [varMetric, chainVar.chainSelector],
+                )
+
+                + var.query.selectionOptions.withIncludeAll(
+                    value=if (!multiInstance && std.member(instanceLabels, chainVar.label)) then false else true,
+                    customAllValue=if index>0 then '.+' else null,
+                )
+                + var.query.selectionOptions.withMulti(
+                    if (!multiInstance && std.member(instanceLabels, chainVar.label)) then false else true,
+                )
+                + var.query.withRefresh(2)
+                + var.query.withSort(
+                    i=1,
+                    type='alphabetical',
+                    asc=true,
+                    caseInsensitive=false
+                );
+                std.mapWithIndex(chainVarProto, utils.chainLabels(groupLabels+instanceLabels, [filterSelector])),
+
+        datasource:
+            var.datasource.new('datasource', 'prometheus')
+            + var.datasource.generalOptions.withLabel('Data Source'),
+
+        multiInstance:
+            [self.datasource]
+            + variablesFromLabels(groupLabels, instanceLabels, filterSelector),
+        singleInstance:
+            [self.datasource]
+            + variablesFromLabels(groupLabels, instanceLabels, filterSelector, multiInstance=false),
+
+        queriesSelector:
+        '%s,%s' % [
+            filterSelector,
+            utils.labelsToPromQLSelector(groupLabels+instanceLabels),
+        ],
+    }
+}