pkg/manifests: enforce label scrape limits for UWM

This commit add feature to support label scrape limits in user workload monitoring by
allowing cluster admin set enforcedLabelLimit, enforcedLabelNameLengthLimit and
enforcedLabelValueLengthLimit in config map

Signed-off-by: Jayapriya Pai <janantha@redhat.com>

CHANGELOG.md

@@ -13,6 +13,7 @@
 - [#1373](https://github.com/openshift/cluster-monitoring-operator/pull/1373) Enable admins to toggle the [query_log_file](https://prometheus.io/docs/guides/query-log/#enable-the-query-log) setting for Prometheus.
 - [#1491](https://github.com/openshift/cluster-monitoring-operator/pull/1491) Rename alerts `AggregatedAPIErrors to KubeAggregatedAPIErrors` and `AggregatedAPIDown to KubeAggregatedAPIDown`.
 - [#1488](https://github.com/openshift/cluster-monitoring-operator/pull/1488) Removing the alert HighlyAvailableWorkloadIncorrectlySpread.
+- [#1350](https://github.com/openshift/cluster-monitoring-operator/pull/1350) Support label scrape limits in user-workload monitoring
 
 ## 4.9
 

pkg/manifests/config.go

@@ -509,18 +509,21 @@ type UserWorkloadConfiguration struct {
 }
 
 type PrometheusRestrictedConfig struct {
-	LogLevel            string                               `json:"logLevel"`
-	Retention           string                               `json:"retention"`
-	NodeSelector        map[string]string                    `json:"nodeSelector"`
-	Tolerations         []v1.Toleration                      `json:"tolerations"`
-	Resources           *v1.ResourceRequirements             `json:"resources"`
-	ExternalLabels      map[string]string                    `json:"externalLabels"`
-	VolumeClaimTemplate *monv1.EmbeddedPersistentVolumeClaim `json:"volumeClaimTemplate"`
-	RemoteWrite         []RemoteWriteSpec                    `json:"remoteWrite"`
-	EnforcedSampleLimit *uint64                              `json:"enforcedSampleLimit"`
-	EnforcedTargetLimit *uint64                              `json:"enforcedTargetLimit"`
-	AlertmanagerConfigs []AdditionalAlertmanagerConfig       `json:"additionalAlertmanagerConfigs"`
-	QueryLogFile        string                               `json:"queryLogFile"`
+	LogLevel                      string                               `json:"logLevel"`
+	Retention                     string                               `json:"retention"`
+	NodeSelector                  map[string]string                    `json:"nodeSelector"`
+	Tolerations                   []v1.Toleration                      `json:"tolerations"`
+	Resources                     *v1.ResourceRequirements             `json:"resources"`
+	ExternalLabels                map[string]string                    `json:"externalLabels"`
+	VolumeClaimTemplate           *monv1.EmbeddedPersistentVolumeClaim `json:"volumeClaimTemplate"`
+	RemoteWrite                   []RemoteWriteSpec                    `json:"remoteWrite"`
+	EnforcedSampleLimit           *uint64                              `json:"enforcedSampleLimit"`
+	EnforcedTargetLimit           *uint64                              `json:"enforcedTargetLimit"`
+	EnforcedLabelLimit            *uint64                              `json:"enforcedLabelLimit"`
+	EnforcedLabelNameLengthLimit  *uint64                              `json:"enforcedLabelNameLengthLimit"`
+	EnforcedLabelValueLengthLimit *uint64                              `json:"enforcedLabelValueLengthLimit"`
+	AlertmanagerConfigs           []AdditionalAlertmanagerConfig       `json:"additionalAlertmanagerConfigs"`
+	QueryLogFile                  string                               `json:"queryLogFile"`
 }
 
 func (u *UserWorkloadConfiguration) applyDefaults() {

pkg/manifests/manifests.go

@@ -1707,6 +1707,18 @@ func (f *Factory) PrometheusUserWorkload(grpcTLS *v1.Secret) (*monv1.Prometheus,
 		p.Spec.EnforcedTargetLimit = f.config.UserWorkloadConfiguration.Prometheus.EnforcedTargetLimit
 	}
 
+	if f.config.UserWorkloadConfiguration.Prometheus.EnforcedLabelLimit != nil {
+		p.Spec.EnforcedLabelLimit = f.config.UserWorkloadConfiguration.Prometheus.EnforcedLabelLimit
+	}
+
+	if f.config.UserWorkloadConfiguration.Prometheus.EnforcedLabelNameLengthLimit != nil {
+		p.Spec.EnforcedLabelNameLengthLimit = f.config.UserWorkloadConfiguration.Prometheus.EnforcedLabelNameLengthLimit
+	}
+
+	if f.config.UserWorkloadConfiguration.Prometheus.EnforcedLabelValueLengthLimit != nil {
+		p.Spec.EnforcedLabelValueLengthLimit = f.config.UserWorkloadConfiguration.Prometheus.EnforcedLabelValueLengthLimit
+	}
+
 	if f.config.Images.Thanos != "" {
 		p.Spec.Thanos.Image = &f.config.Images.Thanos
 	}

test/e2e/config_test.go

@@ -526,6 +526,9 @@ func TestUserWorkloadMonitorPrometheusK8Config(t *testing.T) {
 		Data: map[string]string{
 			"config.yaml": fmt.Sprintf(`prometheus:
   enforcedTargetLimit: 10
+	enforcedLabelLimit: 500
+	enforcedLabelNameLengthLimit: 50
+	enforcedLabelValueLengthLimit: 600
   logLevel: debug
   retention: 10h
   queryLogFile: /tmp/test.log
@@ -583,6 +586,18 @@ func TestUserWorkloadMonitorPrometheusK8Config(t *testing.T) {
 			name:      "assert enforced target limit is configured",
 			assertion: assertEnforcedTargetLimit(10),
 		},
+		{
+			"assert enforced label limit is configured",
+			assertEnforcedLabelLimit(10),
+		},
+
+		{
+			"assert enforced label name length limit is configured",
+			assertEnforcedLabelNameLengthLimit(25),
+		},
+		{"assert enforced label value length limit",
+			assertEnforcedLabelValueLengthLimit(5),
+		},
 		{
 			name:      "assert query log file value is set and correct",
 			assertion: assertQueryLogValueEquals(f.UserWorkloadMonitoringNs, crName, "/tmp/test.log"),
@@ -824,6 +839,78 @@ func assertEnforcedTargetLimit(limit uint64) func(*testing.T) {
 	}
 }
 
+func assertEnforcedLabelLimit(limit uint64) func(*testing.T) {
+	ctx := context.Background()
+	return func(t *testing.T) {
+		err := framework.Poll(time.Second, 5*time.Minute, func() error {
+			prom, err := f.MonitoringClient.Prometheuses(f.UserWorkloadMonitoringNs).Get(ctx, "user-workload", metav1.GetOptions{})
+			if err != nil {
+				return err
+			}
+
+			if prom.Spec.EnforcedLabelLimit == nil {
+				return errors.New("EnforcedLabelLimit not set")
+			} else if *prom.Spec.EnforcedLabelLimit != limit {
+				return fmt.Errorf("expected EnforcedLabelLimit to be %d, but got %d", limit, *prom.Spec.EnforcedLabelLimit)
+			}
+
+			return nil
+		})
+
+		if err != nil {
+			t.Fatalf("Timed out waiting for EnforcedLabelLimit configuration: %v", err)
+		}
+	}
+}
+
+func assertEnforcedLabelNameLengthLimit(limit uint64) func(*testing.T) {
+	ctx := context.Background()
+	return func(t *testing.T) {
+		err := framework.Poll(time.Second, 5*time.Minute, func() error {
+			prom, err := f.MonitoringClient.Prometheuses(f.UserWorkloadMonitoringNs).Get(ctx, "user-workload", metav1.GetOptions{})
+			if err != nil {
+				return err
+			}
+
+			if prom.Spec.EnforcedLabelNameLengthLimit == nil {
+				return errors.New("EnforcedLabelNameLengthLimit not set")
+			} else if *prom.Spec.EnforcedLabelNameLengthLimit != limit {
+				return fmt.Errorf("expected EnforcedLabelNameLengthLimit to be %d, but got %d", limit, *prom.Spec.EnforcedLabelNameLengthLimit)
+			}
+
+			return nil
+		})
+
+		if err != nil {
+			t.Fatalf("Timed out waiting for EnforcedLabelNameLengthLimit configuration: %v", err)
+		}
+	}
+}
+
+func assertEnforcedLabelValueLengthLimit(limit uint64) func(*testing.T) {
+	ctx := context.Background()
+	return func(t *testing.T) {
+		err := framework.Poll(time.Second, 5*time.Minute, func() error {
+			prom, err := f.MonitoringClient.Prometheuses(f.UserWorkloadMonitoringNs).Get(ctx, "user-workload", metav1.GetOptions{})
+			if err != nil {
+				return err
+			}
+
+			if prom.Spec.EnforcedLabelValueLengthLimit == nil {
+				return errors.New("EnforcedLabelValueLengthLimit not set")
+			} else if *prom.Spec.EnforcedLabelValueLengthLimit != limit {
+				return fmt.Errorf("expected EnforcedLabelValueLengthLimit to be %d, but got %d", limit, *prom.Spec.EnforcedLabelValueLengthLimit)
+			}
+
+			return nil
+		})
+
+		if err != nil {
+			t.Fatalf("Timed out waiting for EnforcedLabelValueLengthLimit configuration: %v", err)
+		}
+	}
+}
+
 func assertQueryLogValueEquals(namespace, crName, value string) func(t *testing.T) {
 	return func(t *testing.T) {
 		err := framework.Poll(time.Second, time.Minute*5, func() error {