feat: custom monitoring

Signed-off-by: huanggze <loganhuang@yunify.com>

pkg/models/monitoring/expressions/prometheus/label_replace.go

@@ -0,0 +1,99 @@
+package prometheus
+
+import (
+	"fmt"
+	"github.com/prometheus/common/model"
+	"github.com/prometheus/prometheus/promql"
+	"github.com/prometheus/prometheus/storage/metric"
+	"kubesphere.io/kubesphere/pkg/models/monitoring/expressions"
+)
+
+func init() {
+	expressions.Register("prometheus", labelReplace)
+}
+
+func labelReplace(input, ns string) (string, error) {
+	root, err := promql.ParseExpr(input)
+	if err != nil {
+		return "", err
+	}
+
+	SetRecursive(root, ns)
+	if err != nil {
+		return "", err
+	}
+
+	return root.String(), nil
+}
+
+// Inspired by https://github.com/openshift/prom-label-proxy
+func SetRecursive(node promql.Node, namespace string) (err error) {
+	switch n := node.(type) {
+	case *promql.EvalStmt:
+		if err := SetRecursive(n.Expr, namespace); err != nil {
+			return err
+		}
+	case promql.Expressions:
+		for _, e := range n {
+			if err := SetRecursive(e, namespace); err != nil {
+				return err
+			}
+		}
+	case *promql.AggregateExpr:
+		if err := SetRecursive(n.Expr, namespace); err != nil {
+			return err
+		}
+	case *promql.BinaryExpr:
+		if err := SetRecursive(n.LHS, namespace); err != nil {
+			return err
+		}
+		if err := SetRecursive(n.RHS, namespace); err != nil {
+			return err
+		}
+	case *promql.Call:
+		if err := SetRecursive(n.Args, namespace); err != nil {
+			return err
+		}
+	case *promql.ParenExpr:
+		if err := SetRecursive(n.Expr, namespace); err != nil {
+			return err
+		}
+	case *promql.UnaryExpr:
+		if err := SetRecursive(n.Expr, namespace); err != nil {
+			return err
+		}
+	case *promql.NumberLiteral, *promql.StringLiteral:
+		// nothing to do
+	case *promql.MatrixSelector:
+		n.LabelMatchers = enforceLabelMatchers(n.LabelMatchers, namespace)
+	case *promql.VectorSelector:
+		n.LabelMatchers = enforceLabelMatchers(n.LabelMatchers, namespace)
+	default:
+		return fmt.Errorf("promql.Walk: unhandled node type %T", node)
+	}
+	return err
+}
+
+func enforceLabelMatchers(matchers metric.LabelMatchers, namespace string) metric.LabelMatchers {
+	var found bool
+	for i, m := range matchers {
+		if m.Name == "namespace" {
+			matchers[i] = &metric.LabelMatcher{
+				Name:  "namespace",
+				Type:  metric.Equal,
+				Value: model.LabelValue(namespace),
+			}
+			found = true
+			break
+		}
+	}
+
+	if !found {
+		matchers = append(matchers, &metric.LabelMatcher{
+			Name:  "namespace",
+			Type:  metric.Equal,
+			Value: model.LabelValue(namespace),
+		})
+	}
+	return matchers
+}

pkg/models/monitoring/expressions/prometheus/label_replace_test.go

@@ -0,0 +1,51 @@
+package prometheus
+
+import (
+	"fmt"
+	"github.com/google/go-cmp/cmp"
+	"testing"
+)
+
+func TestLabelReplace(t *testing.T) {
+	tests := []struct {
+		expr        string
+		expected    string
+		expectedErr bool
+	}{
+		{
+			expr:        "up",
+			expected:    `up{namespace="default"}`,
+			expectedErr: false,
+		},
+		{
+			expr:        `up{namespace="random"}`,
+			expected:    `up{namespace="default"}`,
+			expectedErr: false,
+		},
+		{
+			expr:        `up{namespace="random"} + up{job="test"}`,
+			expected:    `up{namespace="default"} + up{job="test",namespace="default"}`,
+			expectedErr: false,
+		},
+		{
+			expr:        `@@@@`,
+			expectedErr: true,
+		},
+	}
+
+	for i, tt := range tests {
+		t.Run(fmt.Sprintf("%d", i), func(t *testing.T) {
+			result, err := labelReplace(tt.expr, "default")
+			if err != nil {
+				if !tt.expectedErr {
+					t.Fatal(err)
+				}
+				return
+			}
+
+			if diff := cmp.Diff(result, tt.expected); diff != "" {
+				t.Fatalf("%T differ (-got, +want): %s", tt.expected, diff)
+			}
+		})
+	}
+}

pkg/models/monitoring/expressions/registry.go

@@ -0,0 +1,9 @@
+package expressions
+
+type labelReplaceFn func(expr, ns string) (string, error)
+
+var ReplaceNamespaceFns = make(map[string]labelReplaceFn)
+
+func Register(name string, fn labelReplaceFn) {
+	ReplaceNamespaceFns[name] = fn
+}