refactor(prometheus): shard mixins over multiple configmaps

mixin-utils/utils.libsonnet

@@ -140,4 +140,29 @@ local g = import 'grafana-builder/grafana.libsonnet';
       }
       for group in groups
     ],
+
+  removeRuleGroup(ruleName):: {
+    local removeRuleGroup(rule) = if rule.name == ruleName then null else rule,
+    local currentRuleGroups = super.groups,
+    groups: std.prune(std.map(removeRuleGroup, currentRuleGroups)),
+  },
+
+  removeAlertRuleGroup(ruleName):: {
+    prometheusAlerts+:: $.removeRuleGroup(ruleName),
+  },
+
+  removeRecordingRuleGroup(ruleName):: {
+    prometheusRules+:: $.removeRuleGroup(ruleName),
+  },
+
+  overrideAlerts(overrides):: {
+    local overrideRule(rule) =
+      if 'alert' in rule && std.objectHas(overrides, rule.alert)
+      then rule + overrides[rule.alert]
+      else rule,
+    local overrideInGroup(group) = group { rules: std.map(overrideRule, super.rules) },
+    prometheusAlerts+:: {
+      groups: std.map(overrideInGroup, super.groups),
+    },
+  },
 }

prometheus-ksonnet/lib/prometheus.libsonnet

@@ -19,8 +19,8 @@ prometheus_mixins {
     _config+:: $._config { name: name },
     _images+:: $._images,
     mixins:: $.mixins,
-    prometheusRules:: $.prometheusRules,
-    prometheusAlerts:: $.prometheusAlerts,
+    prometheusRules:: if std.objectHas($, 'prometheusRules') then $.prometheusRules else {},
+    prometheusAlerts:: if std.objectHas($, 'prometheusAlerts') then $.prometheusAlerts else {},
     prometheus_config+:: $.prometheus_config,
 
   },

prometheus/mixins.libsonnet

@@ -1,4 +1,9 @@
-{
+local k = import 'ksonnet-util/kausal.libsonnet';
+
+(import 'config.libsonnet')
++ {
+  local _config = self._config,
+
   mixins+:: {
     base+: {
       prometheusAlerts+: {
@@ -58,21 +63,68 @@
     prometheusRules+:: {},
   },
 
-  prometheusAlerts::
-    std.foldr(
-      function(mixinName, acc)
-        local mixin = $.mixins[mixinName] + emptyMixin;
-        acc + mixin.prometheusAlerts,
-      std.objectFields($.mixins),
-      {}
-    ),
+  withMixinsConfigmaps(mixins):: {
+    local configMap = k.core.v1.configMap,
+    prometheus_config_maps_mixins+: [
+      local mixin = mixins[mixinName] + emptyMixin;
+      local prometheusAlerts = mixin.prometheusAlerts;
+      local prometheusRules = mixin.prometheusRules;
+      configMap.new(
+        std.strReplace('%s-%s-mixin' % [_config.name, mixinName], '_', '-')
+      )
+      + configMap.withData({
+        'alerts.rules': k.util.manifestYaml(prometheusAlerts),
+        'recording.rules': k.util.manifestYaml(prometheusRules),
+      })
+      for mixinName in std.objectFields(mixins)
+    ],
+
+    prometheus_config+: {
+      rule_files+:
+        std.foldr(
+          function(mixinName, acc)
+            acc + [
+              'mixins/%s/alerts.rules' % mixinName,
+              'mixins/%s/recording.rules' % mixinName,
+            ],
+          std.objectFields(mixins),
+          []
+        ),
+    },
 
-  prometheusRules::
-    std.foldr(
-      function(mixinName, acc)
-        local mixin = $.mixins[mixinName] + emptyMixin;
-        acc + mixin.prometheusRules,
-      std.objectFields($.mixins),
-      {},
-    ),
+    prometheus_config_mount+::
+      std.foldr(
+        function(mixinName, acc)
+          acc
+          + k.util.configVolumeMount(
+            std.strReplace('%s-%s-mixin' % [_config.name, mixinName], '_', '-'),
+            '%s/mixins/%s' % [_config.prometheus_config_dir, mixinName]
+          ),
+        std.objectFields(mixins),
+        {}
+      ),
+  },
+
+  // Extends legacy extension points with the mixins object, adding
+  // the alerts and recording rules to root-level. This functions
+  // should be applied if you want to retain the legacy behavior.
+  withMixinsLegacyConfigmaps(mixins):: {
+    prometheusAlerts+::
+      std.foldr(
+        function(mixinName, acc)
+          local mixin = mixins[mixinName] + emptyMixin;
+          acc + mixin.prometheusAlerts,
+        std.objectFields(mixins),
+        {}
+      ),
+
+    prometheusRules+::
+      std.foldr(
+        function(mixinName, acc)
+          local mixin = mixins[mixinName] + emptyMixin;
+          acc + mixin.prometheusRules,
+        std.objectFields(mixins),
+        {},
+      ),
+  },
 }