From dcf53d63fcd90513139b654e024ebc630f422392 Mon Sep 17 00:00:00 2001 From: Arvind Thirumurugan Date: Mon, 17 Nov 2025 16:44:29 -0800 Subject: [PATCH 01/13] add example files Signed-off-by: Arvind Thirumurugan --- cmd/metric-app/main.go | 43 +++++++++++++++++++++++++++++++++ docker/metric-app.Dockerfile | 17 +++++++++++++ examples/sample-metric-app.yaml | 31 ++++++++++++++++++++++++ 3 files changed, 91 insertions(+) create mode 100644 cmd/metric-app/main.go create mode 100644 docker/metric-app.Dockerfile create mode 100644 examples/sample-metric-app.yaml diff --git a/cmd/metric-app/main.go b/cmd/metric-app/main.go new file mode 100644 index 000000000..1ee930796 --- /dev/null +++ b/cmd/metric-app/main.go @@ -0,0 +1,43 @@ +package main + +import ( + "net/http" + "os" + + "github.com/prometheus/client_golang/prometheus" + "github.com/prometheus/client_golang/prometheus/promhttp" +) + +func main() { + // Get cluster and workload information from environment variables + clusterName := os.Getenv("CLUSTER_NAME") + if clusterName == "" { + clusterName = "unknown" + } + + workloadName := os.Getenv("WORKLOAD_NAME") + if workloadName == "" { + workloadName = "unknown" + } + + // Define a simple gauge metric for health with labels + workloadHealth := prometheus.NewGaugeVec( + prometheus.GaugeOpts{ + Name: "workload_health", + Help: "Indicates if the workload is healthy (1=healthy, 0=unhealthy)", + }, + []string{"cluster_name", "workload_name"}, + ) + + // Set it to 1 (healthy) with labels + workloadHealth.WithLabelValues(clusterName, workloadName).Set(1) + + // Register metric with Prometheus default registry + prometheus.MustRegister(workloadHealth) + + // Expose metrics endpoint + http.Handle("/metrics", promhttp.Handler()) + + // Start HTTP server + http.ListenAndServe(":8080", nil) +} diff --git a/docker/metric-app.Dockerfile b/docker/metric-app.Dockerfile new file mode 100644 index 000000000..a092fd94f --- /dev/null +++ b/docker/metric-app.Dockerfile @@ -0,0 +1,17 @@ +# Build stage +FROM golang:1.24-alpine AS builder +WORKDIR /workspace +# Copy go mod files +COPY go.mod go.sum ./ +RUN go mod download +# Copy source code +COPY cmd/metric-app/ ./cmd/metric-app/ +# Build the application +RUN CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo -o metric-app ./cmd/metric-app/main.go + +# Run stage +FROM alpine:3.18 +WORKDIR /app +COPY --from=builder /workspace/metric-app . +EXPOSE 8080 +CMD ["./metric-app"] diff --git a/examples/sample-metric-app.yaml b/examples/sample-metric-app.yaml new file mode 100644 index 000000000..8103b7381 --- /dev/null +++ b/examples/sample-metric-app.yaml @@ -0,0 +1,31 @@ +apiVersion: apps/v1 +kind: Deployment +metadata: + name: sample-metric-app + labels: + app: sample-metric-app +spec: + replicas: 1 + selector: + matchLabels: + app: sample-metric-app + template: + metadata: + labels: + app: sample-metric-app + annotations: + prometheus.io/scrape: "true" + prometheus.io/port: "8080" + prometheus.io/path: "/metrics" + spec: + containers: + - name: metric-app + image: ghcr.io/metric-app:6d6cd69 + imagePullPolicy: IfNotPresent + ports: + - containerPort: 8080 + env: + - name: CLUSTER_NAME + value: "cluster-1" + - name: WORKLOAD_NAME + value: "sample-metric-app" From c44423c3b325d6ebfc60eeefe5a3762570c3c948 Mon Sep 17 00:00:00 2001 From: Arvind Thirumurugan Date: Mon, 17 Nov 2025 17:16:12 -0800 Subject: [PATCH 02/13] fix yaml files Signed-off-by: Arvind Thirumurugan --- examples/sample-metric-app-crp.yaml | 14 ++++++++ examples/sample-metric-app-ro.yaml | 56 +++++++++++++++++++++++++++++ examples/sample-metric-app.yaml | 1 + 3 files changed, 71 insertions(+) create mode 100644 examples/sample-metric-app-crp.yaml create mode 100644 examples/sample-metric-app-ro.yaml diff --git a/examples/sample-metric-app-crp.yaml b/examples/sample-metric-app-crp.yaml new file mode 100644 index 000000000..0da5fdfa9 --- /dev/null +++ b/examples/sample-metric-app-crp.yaml @@ -0,0 +1,14 @@ +apiVersion: placement.kubernetes-fleet.io/v1beta1 +kind: ClusterResourcePlacement +metadata: + name: sample-metric-app +spec: + resourceSelectors: + - group: "" + version: v1 + kind: Namespace + name: test-ns + policy: + placementType: PickAll + strategy: + type: RollingUpdate diff --git a/examples/sample-metric-app-ro.yaml b/examples/sample-metric-app-ro.yaml new file mode 100644 index 000000000..51f900d0e --- /dev/null +++ b/examples/sample-metric-app-ro.yaml @@ -0,0 +1,56 @@ +apiVersion: placement.kubernetes-fleet.io/v1alpha1 +kind: ResourceOverride +metadata: + name: metric-app-override + namespace: test-ns +spec: + placement: + name: sample-metric-app + resourceSelectors: + - group: apps + version: v1 + kind: Deployment + name: sample-metric-app + policy: + overrideRules: + # Override for kind-cluster-1 + - clusterSelector: + clusterSelectorTerms: + - labelSelector: + matchLabels: + cluster-name: kind-cluster-1 + jsonPatchOverrides: + - op: replace + path: /spec/template/spec/containers/0/env/0/value + value: "kind-cluster-1" + - op: replace + path: /spec/template/spec/containers/0/env/1/value + value: "sample-metric-app-cluster-1" + + # Override for kind-cluster-2 + - clusterSelector: + clusterSelectorTerms: + - labelSelector: + matchLabels: + cluster-name: kind-cluster-2 + jsonPatchOverrides: + - op: replace + path: /spec/template/spec/containers/0/env/0/value + value: "kind-cluster-2" + - op: replace + path: /spec/template/spec/containers/0/env/1/value + value: "sample-metric-app-cluster-2" + + # Override for kind-cluster-3 + - clusterSelector: + clusterSelectorTerms: + - labelSelector: + matchLabels: + cluster-name: kind-cluster-3 + jsonPatchOverrides: + - op: replace + path: /spec/template/spec/containers/0/env/0/value + value: "kind-cluster-3" + - op: replace + path: /spec/template/spec/containers/0/env/1/value + value: "sample-metric-app-cluster-3" diff --git a/examples/sample-metric-app.yaml b/examples/sample-metric-app.yaml index 8103b7381..71dc503c9 100644 --- a/examples/sample-metric-app.yaml +++ b/examples/sample-metric-app.yaml @@ -2,6 +2,7 @@ apiVersion: apps/v1 kind: Deployment metadata: name: sample-metric-app + namespace: test-ns labels: app: sample-metric-app spec: From d9cf48a5f18b544b4c48488a36dd43f49df42497 Mon Sep 17 00:00:00 2001 From: Arvind Thirumurugan Date: Wed, 19 Nov 2025 15:18:43 -0800 Subject: [PATCH 03/13] add prometheus manifests Signed-off-by: Arvind Thirumurugan --- .../v1beta1/metriccollector_types.go | 276 +++++++++++ .../v1beta1/zz_generated.deepcopy.go | 279 ++++++++++- examples/metrics/README.md | 456 ++++++++++++++++++ examples/metrics/metriccollector-sample.yaml | 72 +++ examples/prometheus/README.md | 117 +++++ examples/prometheus/configmap.yaml | 44 ++ examples/prometheus/deployment.yaml | 48 ++ examples/prometheus/rbac.yaml | 39 ++ examples/prometheus/service.yaml | 16 + examples/sample-metric-app-crp.yaml | 8 + pkg/controllers/metriccollector/collector.go | 324 +++++++++++++ pkg/controllers/metriccollector/controller.go | 236 +++++++++ test/e2e/kindconfigs/cluster-2.yaml | 2 +- test/e2e/kindconfigs/cluster-3.yaml | 4 +- tools/prometheus-test/README.md | 69 +++ tools/prometheus-test/main.go | 127 +++++ 16 files changed, 2113 insertions(+), 4 deletions(-) create mode 100644 apis/placement/v1beta1/metriccollector_types.go create mode 100644 examples/metrics/README.md create mode 100644 examples/metrics/metriccollector-sample.yaml create mode 100644 examples/prometheus/README.md create mode 100644 examples/prometheus/configmap.yaml create mode 100644 examples/prometheus/deployment.yaml create mode 100644 examples/prometheus/rbac.yaml create mode 100644 examples/prometheus/service.yaml create mode 100644 pkg/controllers/metriccollector/collector.go create mode 100644 pkg/controllers/metriccollector/controller.go create mode 100644 tools/prometheus-test/README.md create mode 100644 tools/prometheus-test/main.go diff --git a/apis/placement/v1beta1/metriccollector_types.go b/apis/placement/v1beta1/metriccollector_types.go new file mode 100644 index 000000000..cfa9cf01f --- /dev/null +++ b/apis/placement/v1beta1/metriccollector_types.go @@ -0,0 +1,276 @@ +/* +Copyright 2025 The KubeFleet Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package v1beta1 + +import ( + "k8s.io/apimachinery/pkg/api/meta" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + + "github.com/kubefleet-dev/kubefleet/apis" +) + +// +genclient +// +kubebuilder:object:root=true +// +kubebuilder:resource:scope="Namespaced",shortName=mc,categories={fleet,fleet-metrics} +// +kubebuilder:subresource:status +// +kubebuilder:storageversion +// +kubebuilder:printcolumn:JSONPath=`.metadata.generation`,name="Gen",type=string +// +kubebuilder:printcolumn:JSONPath=`.status.conditions[?(@.type=="MetricCollectorReady")].status`,name="Ready",type=string +// +kubebuilder:printcolumn:JSONPath=`.status.workloadsMonitored`,name="Workloads",type=integer +// +kubebuilder:printcolumn:JSONPath=`.status.lastCollectionTime`,name="Last-Collection",type=date +// +kubebuilder:printcolumn:JSONPath=`.metadata.creationTimestamp`,name="Age",type=date + +// MetricCollector is used by member-agent to scrape and collect metrics from workloads +// running on the member cluster. It runs on each member cluster and collects metrics +// from Prometheus-compatible endpoints. +type MetricCollector struct { + metav1.TypeMeta `json:",inline"` + metav1.ObjectMeta `json:"metadata,omitempty"` + + // The desired state of MetricCollector. + // +required + Spec MetricCollectorSpec `json:"spec"` + + // The observed status of MetricCollector. + // +optional + Status MetricCollectorStatus `json:"status,omitempty"` +} + +// MetricCollectorSpec defines the desired state of MetricCollector. +type MetricCollectorSpec struct { + // WorkloadSelector defines which workloads to monitor. + // +required + WorkloadSelector WorkloadSelectorSpec `json:"workloadSelector"` + + // MetricsEndpoint defines how to access the metrics endpoint. + // +required + MetricsEndpoint MetricsEndpointSpec `json:"metricsEndpoint"` + + // CollectionInterval specifies how often to scrape metrics. + // Default is 30s. Minimum is 10s. + // +kubebuilder:default="30s" + // +kubebuilder:validation:Pattern="^([0-9]+(\\.[0-9]+)?(s|m|h))+$" + // +optional + CollectionInterval string `json:"collectionInterval,omitempty"` + + // MetricsToCollect specifies which metrics to collect from the endpoint. + // If empty, specific metrics like workload_health will be collected. + // +optional + // +kubebuilder:validation:MaxItems=50 + MetricsToCollect []string `json:"metricsToCollect,omitempty"` +} + +// WorkloadSelectorSpec defines how to select workloads for monitoring. +type WorkloadSelectorSpec struct { + // LabelSelector to match workloads. + // +required + LabelSelector *metav1.LabelSelector `json:"labelSelector"` + + // Namespaces to monitor. If empty, all namespaces are monitored. + // +optional + // +kubebuilder:validation:MaxItems=100 + Namespaces []string `json:"namespaces,omitempty"` + + // WorkloadTypes specifies which types of workloads to monitor. + // Supported: Deployment, StatefulSet, DaemonSet, Pod. + // If empty, only Pods are monitored. + // +optional + // +kubebuilder:validation:MaxItems=10 + WorkloadTypes []string `json:"workloadTypes,omitempty"` +} + +// MetricsEndpointSpec defines how to access the metrics endpoint. +type MetricsEndpointSpec struct { + // SourceType defines the type of metrics source. + // "prometheus" - Query a centralized Prometheus server (recommended for production) + // "direct" - Directly scrape each pod's metrics endpoint + // Default is "prometheus". + // +kubebuilder:validation:Enum=prometheus;direct + // +kubebuilder:default="prometheus" + // +optional + SourceType string `json:"sourceType,omitempty"` + + // PrometheusEndpoint specifies the Prometheus server to query. + // Required when SourceType is "prometheus". + // +optional + PrometheusEndpoint *PrometheusEndpointSpec `json:"prometheusEndpoint,omitempty"` + + // DirectEndpoint specifies how to scrape pods directly. + // Required when SourceType is "direct". + // +optional + DirectEndpoint *DirectEndpointSpec `json:"directEndpoint,omitempty"` +} + +// PrometheusEndpointSpec defines how to connect to a Prometheus server. +type PrometheusEndpointSpec struct { + // URL of the Prometheus server. + // Example: http://prometheus-server.monitoring:9090 + // +kubebuilder:validation:Required + // +kubebuilder:validation:Pattern=`^https?://.*$` + URL string `json:"url"` + + // Auth specifies authentication configuration for Prometheus. + // +optional + Auth *PrometheusAuthConfig `json:"auth,omitempty"` +} + +// PrometheusAuthConfig specifies authentication for Prometheus. +type PrometheusAuthConfig struct { + // Type of authentication (bearer or basic). + // +kubebuilder:validation:Enum=bearer;basic + // +optional + Type string `json:"type,omitempty"` + + // SecretRef references a secret containing authentication credentials. + // For bearer: key "token" + // For basic: keys "username" and "password" + // +optional + SecretRef *SecretReference `json:"secretRef,omitempty"` +} + +// SecretReference identifies a secret. +type SecretReference struct { + // Name of the secret. + // +kubebuilder:validation:Required + // +kubebuilder:validation:MaxLength=253 + Name string `json:"name"` + + // Namespace of the secret. + // If not specified, the namespace of the MetricCollector will be used. + // +optional + Namespace string `json:"namespace,omitempty"` +} + +// DirectEndpointSpec defines how to scrape pods directly. +type DirectEndpointSpec struct { + // Port where metrics are exposed on pods. + // +kubebuilder:validation:Minimum=1 + // +kubebuilder:validation:Maximum=65535 + // +required + Port int32 `json:"port"` + + // Path to the metrics endpoint. + // Default is "/metrics". + // +kubebuilder:default="/metrics" + // +optional + Path string `json:"path,omitempty"` + + // Scheme for the metrics endpoint (http or https). + // Default is "http". + // +kubebuilder:default="http" + // +kubebuilder:validation:Enum=http;https + // +optional + Scheme string `json:"scheme,omitempty"` +} + +// MetricCollectorStatus defines the observed state of MetricCollector. +type MetricCollectorStatus struct { + // Conditions is an array of current observed conditions. + // +optional + Conditions []metav1.Condition `json:"conditions,omitempty"` + + // ObservedGeneration is the generation most recently observed. + // +optional + ObservedGeneration int64 `json:"observedGeneration,omitempty"` + + // WorkloadsMonitored is the count of workloads being monitored. + // +optional + WorkloadsMonitored int32 `json:"workloadsMonitored,omitempty"` + + // LastCollectionTime is when metrics were last collected. + // +optional + LastCollectionTime *metav1.Time `json:"lastCollectionTime,omitempty"` + + // CollectedMetrics contains the most recent metrics from each workload. + // +optional + CollectedMetrics []WorkloadMetrics `json:"collectedMetrics,omitempty"` +} + +// WorkloadMetrics represents metrics collected from a single workload. +type WorkloadMetrics struct { + // WorkloadName is the name of the workload. + // +required + Name string `json:"name"` + + // WorkloadNamespace is the namespace of the workload. + // +required + Namespace string `json:"namespace"` + + // WorkloadKind is the kind of workload (Pod, Deployment, etc.). + // +required + Kind string `json:"kind"` + + // Metrics contains the collected metric values. + // Key is metric name, value is the metric value. + // +optional + Metrics map[string]string `json:"metrics,omitempty"` + + // Labels from the metric (like cluster_name, workload_name from the app). + // +optional + Labels map[string]string `json:"labels,omitempty"` + + // LastScrapedTime is when metrics were last scraped from this workload. + // +optional + LastScrapedTime *metav1.Time `json:"lastScrapedTime,omitempty"` + + // Healthy indicates if the workload is healthy based on metrics. + // +optional + Healthy *bool `json:"healthy,omitempty"` + + // ErrorMessage if scraping failed. + // +optional + ErrorMessage string `json:"errorMessage,omitempty"` +} + +const ( + // MetricCollectorConditionTypeReady indicates the collector is ready. + MetricCollectorConditionTypeReady string = "MetricCollectorReady" + + // MetricCollectorConditionTypeCollecting indicates metrics are being collected. + MetricCollectorConditionTypeCollecting string = "MetricsCollecting" +) + +// +kubebuilder:object:root=true + +// MetricCollectorList contains a list of MetricCollector. +type MetricCollectorList struct { + metav1.TypeMeta `json:",inline"` + metav1.ListMeta `json:"metadata,omitempty"` + Items []MetricCollector `json:"items"` +} + +// GetConditions returns the conditions of the MetricCollector. +func (m *MetricCollector) GetConditions() []metav1.Condition { + return m.Status.Conditions +} + +// SetConditions sets the conditions of the MetricCollector. +func (m *MetricCollector) SetConditions(conditions ...metav1.Condition) { + m.Status.Conditions = conditions +} + +// GetCondition returns the condition of the given MetricCollector. +func (m *MetricCollector) GetCondition(conditionType string) *metav1.Condition { + return meta.FindStatusCondition(m.Status.Conditions, conditionType) +} + +// Ensure MetricCollector implements the ConditionedObj interface. +var _ apis.ConditionedObj = &MetricCollector{} + +func init() { + SchemeBuilder.Register(&MetricCollector{}, &MetricCollectorList{}) +} diff --git a/apis/placement/v1beta1/zz_generated.deepcopy.go b/apis/placement/v1beta1/zz_generated.deepcopy.go index b9ff2e710..011fd7b68 100644 --- a/apis/placement/v1beta1/zz_generated.deepcopy.go +++ b/apis/placement/v1beta1/zz_generated.deepcopy.go @@ -21,7 +21,7 @@ limitations under the License. package v1beta1 import ( - v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/runtime" "k8s.io/apimachinery/pkg/util/intstr" ) @@ -1336,6 +1336,21 @@ func (in *DiffedResourcePlacement) DeepCopy() *DiffedResourcePlacement { return out } +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *DirectEndpointSpec) DeepCopyInto(out *DirectEndpointSpec) { + *out = *in +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new DirectEndpointSpec. +func (in *DirectEndpointSpec) DeepCopy() *DirectEndpointSpec { + if in == nil { + return nil + } + out := new(DirectEndpointSpec) + in.DeepCopyInto(out) + return out +} + // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *DriftDetails) DeepCopyInto(out *DriftDetails) { *out = *in @@ -1483,6 +1498,145 @@ func (in *ManifestCondition) DeepCopy() *ManifestCondition { return out } +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *MetricCollector) DeepCopyInto(out *MetricCollector) { + *out = *in + out.TypeMeta = in.TypeMeta + in.ObjectMeta.DeepCopyInto(&out.ObjectMeta) + in.Spec.DeepCopyInto(&out.Spec) + in.Status.DeepCopyInto(&out.Status) +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MetricCollector. +func (in *MetricCollector) DeepCopy() *MetricCollector { + if in == nil { + return nil + } + out := new(MetricCollector) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object. +func (in *MetricCollector) DeepCopyObject() runtime.Object { + if c := in.DeepCopy(); c != nil { + return c + } + return nil +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *MetricCollectorList) DeepCopyInto(out *MetricCollectorList) { + *out = *in + out.TypeMeta = in.TypeMeta + in.ListMeta.DeepCopyInto(&out.ListMeta) + if in.Items != nil { + in, out := &in.Items, &out.Items + *out = make([]MetricCollector, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MetricCollectorList. +func (in *MetricCollectorList) DeepCopy() *MetricCollectorList { + if in == nil { + return nil + } + out := new(MetricCollectorList) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object. +func (in *MetricCollectorList) DeepCopyObject() runtime.Object { + if c := in.DeepCopy(); c != nil { + return c + } + return nil +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *MetricCollectorSpec) DeepCopyInto(out *MetricCollectorSpec) { + *out = *in + in.WorkloadSelector.DeepCopyInto(&out.WorkloadSelector) + in.MetricsEndpoint.DeepCopyInto(&out.MetricsEndpoint) + if in.MetricsToCollect != nil { + in, out := &in.MetricsToCollect, &out.MetricsToCollect + *out = make([]string, len(*in)) + copy(*out, *in) + } +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MetricCollectorSpec. +func (in *MetricCollectorSpec) DeepCopy() *MetricCollectorSpec { + if in == nil { + return nil + } + out := new(MetricCollectorSpec) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *MetricCollectorStatus) DeepCopyInto(out *MetricCollectorStatus) { + *out = *in + if in.Conditions != nil { + in, out := &in.Conditions, &out.Conditions + *out = make([]v1.Condition, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + if in.LastCollectionTime != nil { + in, out := &in.LastCollectionTime, &out.LastCollectionTime + *out = (*in).DeepCopy() + } + if in.CollectedMetrics != nil { + in, out := &in.CollectedMetrics, &out.CollectedMetrics + *out = make([]WorkloadMetrics, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MetricCollectorStatus. +func (in *MetricCollectorStatus) DeepCopy() *MetricCollectorStatus { + if in == nil { + return nil + } + out := new(MetricCollectorStatus) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *MetricsEndpointSpec) DeepCopyInto(out *MetricsEndpointSpec) { + *out = *in + if in.PrometheusEndpoint != nil { + in, out := &in.PrometheusEndpoint, &out.PrometheusEndpoint + *out = new(PrometheusEndpointSpec) + (*in).DeepCopyInto(*out) + } + if in.DirectEndpoint != nil { + in, out := &in.DirectEndpoint, &out.DirectEndpoint + *out = new(DirectEndpointSpec) + **out = **in + } +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MetricsEndpointSpec. +func (in *MetricsEndpointSpec) DeepCopy() *MetricsEndpointSpec { + if in == nil { + return nil + } + out := new(MetricsEndpointSpec) + in.DeepCopyInto(out) + return out +} + // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *NamespacedName) DeepCopyInto(out *NamespacedName) { *out = *in @@ -1819,6 +1973,46 @@ func (in *PreferredClusterSelector) DeepCopy() *PreferredClusterSelector { return out } +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *PrometheusAuthConfig) DeepCopyInto(out *PrometheusAuthConfig) { + *out = *in + if in.SecretRef != nil { + in, out := &in.SecretRef, &out.SecretRef + *out = new(SecretReference) + **out = **in + } +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PrometheusAuthConfig. +func (in *PrometheusAuthConfig) DeepCopy() *PrometheusAuthConfig { + if in == nil { + return nil + } + out := new(PrometheusAuthConfig) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *PrometheusEndpointSpec) DeepCopyInto(out *PrometheusEndpointSpec) { + *out = *in + if in.Auth != nil { + in, out := &in.Auth, &out.Auth + *out = new(PrometheusAuthConfig) + (*in).DeepCopyInto(*out) + } +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PrometheusEndpointSpec. +func (in *PrometheusEndpointSpec) DeepCopy() *PrometheusEndpointSpec { + if in == nil { + return nil + } + out := new(PrometheusEndpointSpec) + in.DeepCopyInto(out) + return out +} + // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *PropertySelector) DeepCopyInto(out *PropertySelector) { *out = *in @@ -2671,6 +2865,21 @@ func (in *SchedulingPolicySnapshotStatus) DeepCopy() *SchedulingPolicySnapshotSt return out } +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *SecretReference) DeepCopyInto(out *SecretReference) { + *out = *in +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new SecretReference. +func (in *SecretReference) DeepCopy() *SecretReference { + if in == nil { + return nil + } + out := new(SecretReference) + in.DeepCopyInto(out) + return out +} + // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *ServerSideApplyConfig) DeepCopyInto(out *ServerSideApplyConfig) { *out = *in @@ -3185,6 +3394,74 @@ func (in *WorkStatus) DeepCopy() *WorkStatus { return out } +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *WorkloadMetrics) DeepCopyInto(out *WorkloadMetrics) { + *out = *in + if in.Metrics != nil { + in, out := &in.Metrics, &out.Metrics + *out = make(map[string]string, len(*in)) + for key, val := range *in { + (*out)[key] = val + } + } + if in.Labels != nil { + in, out := &in.Labels, &out.Labels + *out = make(map[string]string, len(*in)) + for key, val := range *in { + (*out)[key] = val + } + } + if in.LastScrapedTime != nil { + in, out := &in.LastScrapedTime, &out.LastScrapedTime + *out = (*in).DeepCopy() + } + if in.Healthy != nil { + in, out := &in.Healthy, &out.Healthy + *out = new(bool) + **out = **in + } +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new WorkloadMetrics. +func (in *WorkloadMetrics) DeepCopy() *WorkloadMetrics { + if in == nil { + return nil + } + out := new(WorkloadMetrics) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *WorkloadSelectorSpec) DeepCopyInto(out *WorkloadSelectorSpec) { + *out = *in + if in.LabelSelector != nil { + in, out := &in.LabelSelector, &out.LabelSelector + *out = new(v1.LabelSelector) + (*in).DeepCopyInto(*out) + } + if in.Namespaces != nil { + in, out := &in.Namespaces, &out.Namespaces + *out = make([]string, len(*in)) + copy(*out, *in) + } + if in.WorkloadTypes != nil { + in, out := &in.WorkloadTypes, &out.WorkloadTypes + *out = make([]string, len(*in)) + copy(*out, *in) + } +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new WorkloadSelectorSpec. +func (in *WorkloadSelectorSpec) DeepCopy() *WorkloadSelectorSpec { + if in == nil { + return nil + } + out := new(WorkloadSelectorSpec) + in.DeepCopyInto(out) + return out +} + // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *WorkloadTemplate) DeepCopyInto(out *WorkloadTemplate) { *out = *in diff --git a/examples/metrics/README.md b/examples/metrics/README.md new file mode 100644 index 000000000..bbc233801 --- /dev/null +++ b/examples/metrics/README.md @@ -0,0 +1,456 @@ +# Metric Collection API Examples + +This directory contains examples for the Fleet metric collection system. + +## Architecture + +## Architecture + +``` +Hub Cluster Member Cluster +┌─────────────────────┐ ┌─────────────────────┐ +│ MetricsAggregator │ │ MetricCollector CR │ +│ (cluster-scoped) │ │ (fleet-system ns) │ +└──────────┬──────────┘ └─────────┬───────────┘ + │ │ + ↓ ↓ +┌─────────────────────┐ ┌─────────────────────┐ +│ MA Controller │ │ MC Controller │ +│ (in hub-agent) │ │ (in member-agent) │ +│ │ │ │ +│ 1. Read IMC status │ │ Choose approach: │ +│ 2. Aggregate metrics│ │ │ +│ 3. Determine health │◄──reports via IMC─┤ Prometheus Mode: │ +│ 4. Update MA status │ │ └─> Query Prometheus│ +└─────────────────────┘ │ (1 API call) │ + │ │ + │ Direct Mode: │ + │ └─> Scrape each pod │ + │ (N API calls) │ + └─────────┬───────────┘ + │ + ┌────────────────────────────┼─────────────┐ + │ │ │ + ↓ ↓ ↓ + ┌─────────────────────┐ ┌─────────────────────┐ ... + │ Prometheus Server │ │ sample-metric-app │ + │ :9090/api/v1/query │ │ Pod :8080/metrics │ + │ │ │ workload_health=1 │ + │ Scrapes pods ───────┼───>│ │ + └─────────────────────┘ └─────────────────────┘ + ↑ + │ + (Prometheus scrapes) +``` + +## Components + +### MetricCollector (Member Cluster) + +Runs on each member cluster as part of the member-agent. It: +- Watches for workloads matching the selector +- Scrapes Prometheus-compatible metrics endpoints +- Collects specified metrics (e.g., `workload_health`) +- Stores metrics in its status +- Reports metrics to hub via InternalMemberCluster + +**Example:** +```yaml +apiVersion: placement.kubernetes-fleet.io/v1beta1 +kind: MetricCollector +metadata: + name: sample-app-collector + namespace: fleet-system +spec: + workloadSelector: + labelSelector: + matchLabels: + app: sample-metric-app + namespaces: + - test-ns + metricsEndpoint: + port: 8080 + path: /metrics + collectionInterval: 30s + metricsToCollect: + - workload_health +``` + +### MetricsAggregator (Hub Cluster) + +Runs on the hub cluster as part of the hub-agent. It: +- Reads metrics from InternalMemberCluster statuses +- Aggregates metrics across all member clusters +- Determines workload health based on thresholds +- Provides fleet-wide health view + +**Example:** +```yaml +apiVersion: placement.kubernetes-fleet.io/v1beta1 +kind: MetricsAggregator +metadata: + name: sample-app-aggregator +spec: + metricCollectorRef: + name: sample-app-collector + namespace: fleet-system + healthThreshold: + metricName: workload_health + minValue: "1" +``` + +## Setup + +### 1. Deploy the Sample Metric App + +First, deploy the sample application that exposes metrics: + +```bash +kubectl apply -f ../sample-metric-app.yaml +``` + +This creates a Pod that exposes a `/metrics` endpoint with `workload_health` metric. + +### 2. (Optional) Setup Prometheus + +If using the Prometheus approach (recommended), ensure Prometheus is deployed: + +```bash +# Add Prometheus helm repo +helm repo add prometheus-community https://prometheus-community.github.io/helm-charts +helm repo update + +# Install Prometheus +helm install prometheus prometheus-community/prometheus \ + --namespace monitoring \ + --create-namespace +``` + +Configure Prometheus to scrape your metric-app pods by adding annotations: +```yaml +annotations: + prometheus.io/scrape: "true" + prometheus.io/port: "8080" + prometheus.io/path: "/metrics" +``` + +### 3. Create MetricCollector on Member Clusters + +On each member cluster, create a MetricCollector: + +**Option A: Using Prometheus (Recommended)** +```bash +kubectl apply -f - <:` + - Scrapes metrics using HTTP client + - Parses Prometheus text format +4. Updates MetricCollector status with collected metrics +5. Reports metrics via InternalMemberCluster status + +**Key Difference:** +- Prometheus: **1 API call** → get all workload metrics +- Direct: **N API calls** → one per pod + +### 2. MetricsAggregator Controller (Hub Agent) + +The controller on the hub cluster: + +1. Watches MetricsAggregator CRs +2. Lists InternalMemberClusters (filtered by `clusterSelector` if specified) +3. For each cluster: + - Reads MetricCollector status from IMC + - Extracts workload metrics + - Applies health threshold (e.g., `workload_health >= 1`) + - Determines per-workload and per-cluster health +4. Aggregates across all clusters: + - Counts total/healthy clusters and workloads + - Sets conditions (Ready, Aggregating, AllClustersHealthy) +5. Updates MetricsAggregator status + +## Integration with Sample Metric App + +The metric-app (`cmd/metric-app/main.go`) exposes: + +``` +workload_health{cluster_name="cluster-1", workload_name="sample-metric-app"} 1 +``` + +- **Metric Name**: `workload_health` +- **Labels**: `cluster_name`, `workload_name` (from environment variables) +- **Value**: `1` (healthy) or `0` (unhealthy) + +The MetricCollector scrapes this and stores: +```yaml +metrics: + workload_health: "1" +labels: + cluster_name: "cluster-1" + workload_name: "sample-metric-app" +healthy: true # Because workload_health == 1 +``` + +## Advanced Examples + +### Monitor Multiple Workload Types + +```yaml +apiVersion: placement.kubernetes-fleet.io/v1beta1 +kind: MetricCollector +metadata: + name: multi-workload-collector + namespace: fleet-system +spec: + workloadSelector: + labelSelector: + matchLabels: + tier: backend + workloadTypes: + - Deployment + - StatefulSet + metricsEndpoint: + port: 9090 + path: /metrics + metricsToCollect: + - http_requests_total + - http_request_duration_seconds + - workload_health +``` + +### Cluster-Specific Aggregation + +```yaml +apiVersion: placement.kubernetes-fleet.io/v1beta1 +kind: MetricsAggregator +metadata: + name: prod-clusters-aggregator +spec: + metricCollectorRef: + name: multi-workload-collector + namespace: fleet-system + clusterSelector: + matchLabels: + environment: production + healthThreshold: + metricName: workload_health + minValue: "1" +``` + +## Troubleshooting + +### Metrics Not Being Collected + +Check MetricCollector status: +```bash +kubectl get mc sample-app-collector -n fleet-system -o jsonpath='{.status.conditions}' +``` + +Common issues: +- Pod selector not matching any pods +- Wrong port or path +- Network policy blocking access to pod metrics endpoint +- Workload not exposing metrics + +### Aggregator Not Showing Metrics + +Check: +1. MetricCollector is running and collecting on member clusters +2. InternalMemberCluster status contains metrics +3. MetricsAggregator `metricCollectorRef` matches the MetricCollector name/namespace + +```bash +# On hub cluster +kubectl get imc -A -o yaml | grep -A 20 "collectedMetrics" +``` + +## Future Enhancements + +- Support for multiple health metrics +- Alerting based on aggregated metrics +- Historical metric trends +- Integration with external monitoring systems +- Automatic scaling based on metrics diff --git a/examples/metrics/metriccollector-sample.yaml b/examples/metrics/metriccollector-sample.yaml new file mode 100644 index 000000000..7f28980e4 --- /dev/null +++ b/examples/metrics/metriccollector-sample.yaml @@ -0,0 +1,72 @@ +# MetricCollector - Runs on Member Cluster +# This collects metrics from the sample-metric-app running on the member cluster + +--- +# Example 1: Using Prometheus (Recommended for Production) +apiVersion: placement.kubernetes-fleet.io/v1beta1 +kind: MetricCollector +metadata: + name: sample-app-collector-prometheus + namespace: fleet-system +spec: + # Select workloads with the app=sample-metric-app label + workloadSelector: + labelSelector: + matchLabels: + app: sample-metric-app + # Monitor in test-ns namespace + namespaces: + - test-ns + + # Query Prometheus server for metrics (centralized approach) + metricsEndpoint: + sourceType: prometheus + prometheusEndpoint: + # URL of Prometheus server in the cluster + url: http://prometheus-server.monitoring:9090 + # Optional: add auth if Prometheus is secured + # auth: + # type: bearer + # secretRef: + # name: prometheus-token + + # Scrape every 30 seconds + collectionInterval: 30s + + # Collect the workload_health metric (others can be added) + metricsToCollect: + - workload_health + +--- +# Example 2: Direct Pod Scraping (Simple, no Prometheus required) +apiVersion: placement.kubernetes-fleet.io/v1beta1 +kind: MetricCollector +metadata: + name: sample-app-collector-direct + namespace: fleet-system +spec: + # Select workloads with the app=sample-metric-app label + workloadSelector: + labelSelector: + matchLabels: + app: sample-metric-app + namespaces: + - test-ns + # When using direct scraping, specify Pod to scrape pod IPs + workloadTypes: + - Pod + + # Directly scrape each pod's metrics endpoint + metricsEndpoint: + sourceType: direct + directEndpoint: + port: 8080 + path: /metrics + scheme: http + + # Scrape every 30 seconds + collectionInterval: 30s + + # Collect the workload_health metric + metricsToCollect: + - workload_health diff --git a/examples/prometheus/README.md b/examples/prometheus/README.md new file mode 100644 index 000000000..bd1b9e66e --- /dev/null +++ b/examples/prometheus/README.md @@ -0,0 +1,117 @@ +# Prometheus Setup for MetricCollector Testing + +This directory contains manifests to deploy Prometheus for testing the MetricCollector controller with the sample-metric-app. + +## Prerequisites + +- Kind cluster running (e.g., cluster-1, cluster-2, or cluster-3) +- `test-ns` namespace exists +- `ghcr.io/metric-app:6d6cd69` image loaded into the cluster + +## Quick Start + +```bash +# Switch to target cluster +kubectl config use-context kind-cluster-1 + +# Create namespace if needed +kubectl create namespace test-ns --dry-run=client -o yaml | kubectl apply -f - + +# Deploy Prometheus +kubectl apply -f rbac.yaml +kubectl apply -f configmap.yaml +kubectl apply -f deployment.yaml +kubectl apply -f service.yaml + +# Deploy sample-metric-app (from parent examples directory) +kubectl apply -f ../sample-metric-app.yaml + +# Wait for pods to be ready +kubectl wait --for=condition=ready pod -l app=prometheus -n test-ns --timeout=60s +kubectl wait --for=condition=ready pod -l app=sample-metric-app -n test-ns --timeout=60s +``` + +## Verify Setup + +### Check Prometheus is scraping metrics + +```bash +# Port-forward Prometheus +kubectl port-forward -n test-ns svc/prometheus 9090:9090 +``` + +Open http://localhost:9090 in your browser and: +1. Go to Status > Targets - you should see `sample-metric-app` pod listed +2. Go to Graph and query: `workload_health` - you should see metrics + +### Test with prometheus-test tool + +```bash +# In another terminal (while port-forward is running) +cd tools/prometheus-test +go build -o prometheus-test main.go +./prometheus-test http://localhost:9090 workload_health + +# Or with namespace filter +./prometheus-test http://localhost:9090 workload_health test-ns +``` + +Expected output: +``` +Querying Prometheus at: http://localhost:9090 +Query: workload_health{namespace="test-ns"} + +Status: success +Result Type: vector +Number of results: 1 + +Result 1: + Labels: + app: sample-metric-app + namespace: test-ns + pod: sample-metric-app-xxxxx + Timestamp: 1732032000.0 + Value: 1 +``` + +## Configuration Details + +### Prometheus ConfigMap +The Prometheus configuration discovers pods with these annotations: +- `prometheus.io/scrape: "true"` - Enable scraping +- `prometheus.io/port: "8080"` - Port to scrape +- `prometheus.io/path: "/metrics"` - Metrics endpoint path + +The sample-metric-app already has these annotations configured. + +### RBAC +Prometheus needs permissions to discover and scrape pods. The `rbac.yaml` creates: +- ServiceAccount for Prometheus +- ClusterRole with pod discovery permissions +- ClusterRoleBinding to grant permissions + +## Testing MetricCollector + +Once Prometheus is running, create a MetricCollector CR: + +```bash +kubectl apply -f - <= 2 { + if value, ok := res.Value[1].(string); ok { + workloadMetricsMap[workloadKey].Metrics[metricName] = value + } + } + } + } + + // Convert map to slice + workloadMetrics := make([]placementv1beta1.WorkloadMetrics, 0, len(workloadMetricsMap)) + for _, wm := range workloadMetricsMap { + // Set health status based on workload_health metric if present + if healthValue, ok := wm.Metrics["workload_health"]; ok { + healthy := false + if healthValue == "1" || healthValue == "1.0" { + healthy = true + } + wm.Healthy = &healthy + } + workloadMetrics = append(workloadMetrics, *wm) + } + + klog.V(2).InfoS("Collected metrics from Prometheus", "workloads", len(workloadMetrics)) + return workloadMetrics, nil +} + +// buildPromQLQueries builds PromQL queries based on workloadSelector and metricsToCollect +func buildPromQLQueries(mc *placementv1beta1.MetricCollector) map[string]string { + queries := make(map[string]string) + selector := mc.Spec.WorkloadSelector + + // Build label selector string + labelSelectors := []string{} + if selector.LabelSelector != nil { + for key, value := range selector.LabelSelector.MatchLabels { + labelSelectors = append(labelSelectors, fmt.Sprintf(`%s="%s"`, key, value)) + } + } + + // Add namespace filter if specified + if len(selector.Namespaces) > 0 { + namespaceFilter := strings.Join(selector.Namespaces, "|") + labelSelectors = append(labelSelectors, fmt.Sprintf(`namespace=~"%s"`, namespaceFilter)) + } + + labelSelectorStr := strings.Join(labelSelectors, ",") + + // Build query for each metric + for _, metricName := range mc.Spec.MetricsToCollect { + if labelSelectorStr != "" { + queries[metricName] = fmt.Sprintf("%s{%s}", metricName, labelSelectorStr) + } else { + queries[metricName] = metricName + } + } + + return queries +} + +// buildWorkloadKey creates a unique key for a workload from metric labels +func buildWorkloadKey(labels map[string]string) string { + namespace := labels["namespace"] + pod := labels["pod"] + if namespace == "" || pod == "" { + return "" + } + return fmt.Sprintf("%s/%s", namespace, pod) +} + +// getWorkloadKind attempts to determine the workload kind from metric labels +func getWorkloadKind(labels map[string]string) string { + // Try common Kubernetes labels + if kind := labels["kind"]; kind != "" { + return kind + } + if labels["deployment"] != "" { + return "Deployment" + } + if labels["statefulset"] != "" { + return "StatefulSet" + } + if labels["daemonset"] != "" { + return "DaemonSet" + } + return "Pod" // Default to Pod if unable to determine +} + +// collectDirect collects metrics by directly scraping pod endpoints +func (r *Reconciler) collectDirect(ctx context.Context, mc *placementv1beta1.MetricCollector) ([]placementv1beta1.WorkloadMetrics, error) { + // TODO: Implement direct pod scraping logic + // 1. List pods using workloadSelector + // 2. For each pod, scrape metrics endpoint + // 3. Parse Prometheus text format + // 4. Return WorkloadMetrics array + return nil, nil +} diff --git a/pkg/controllers/metriccollector/controller.go b/pkg/controllers/metriccollector/controller.go new file mode 100644 index 000000000..6ff5c6806 --- /dev/null +++ b/pkg/controllers/metriccollector/controller.go @@ -0,0 +1,236 @@ +/* +Copyright 2025 The KubeFleet Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package metriccollector + +import ( + "context" + "fmt" + "time" + + "k8s.io/apimachinery/pkg/api/errors" + "k8s.io/apimachinery/pkg/api/meta" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/client-go/tools/record" + "k8s.io/klog/v2" + ctrl "sigs.k8s.io/controller-runtime" + "sigs.k8s.io/controller-runtime/pkg/builder" + "sigs.k8s.io/controller-runtime/pkg/client" + "sigs.k8s.io/controller-runtime/pkg/predicate" + + placementv1beta1 "github.com/kubefleet-dev/kubefleet/apis/placement/v1beta1" +) + +const ( + // defaultCollectionInterval is the default interval for collecting metrics + defaultCollectionInterval = 30 * time.Second + + // minCollectionInterval is the minimum allowed interval for collecting metrics + minCollectionInterval = 10 * time.Second +) + +// Reconciler reconciles a MetricCollector object +type Reconciler struct { + // client is the client to access the member cluster + client.Client + + // recorder is the event recorder + recorder record.EventRecorder + + // prometheusClient is the client to query Prometheus + prometheusClient PrometheusClient + + // metricsCollector collects metrics from pods + metricsCollector MetricsCollector +} + +// Reconcile reconciles a MetricCollector object +func (r *Reconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) { + startTime := time.Now() + klog.V(2).InfoS("MetricCollector reconciliation starts", "metricCollector", req.NamespacedName) + defer func() { + latency := time.Since(startTime).Milliseconds() + klog.V(2).InfoS("MetricCollector reconciliation ends", "metricCollector", req.NamespacedName, "latency", latency) + }() + + // Fetch the MetricCollector instance + mc := &placementv1beta1.MetricCollector{} + if err := r.Get(ctx, req.NamespacedName, mc); err != nil { + if errors.IsNotFound(err) { + klog.V(2).InfoS("MetricCollector not found, ignoring", "metricCollector", req.NamespacedName) + return ctrl.Result{}, nil + } + klog.ErrorS(err, "Failed to get MetricCollector", "metricCollector", req.NamespacedName) + return ctrl.Result{}, err + } + + // Parse collection interval + collectionInterval, err := parseCollectionInterval(mc.Spec.CollectionInterval) + if err != nil { + klog.ErrorS(err, "Invalid collection interval", "metricCollector", req.NamespacedName, "interval", mc.Spec.CollectionInterval) + meta.SetStatusCondition(&mc.Status.Conditions, metav1.Condition{ + Type: placementv1beta1.MetricCollectorConditionTypeReady, + Status: metav1.ConditionFalse, + ObservedGeneration: mc.Generation, + Reason: "InvalidConfiguration", + Message: fmt.Sprintf("Invalid collection interval: %v", err), + }) + if updateErr := r.Status().Update(ctx, mc); updateErr != nil { + klog.ErrorS(updateErr, "Failed to update MetricCollector status", "metricCollector", req.NamespacedName) + return ctrl.Result{}, updateErr + } + return ctrl.Result{RequeueAfter: defaultCollectionInterval}, nil + } + + // Collect metrics based on source type + var collectedMetrics []placementv1beta1.WorkloadMetrics + var collectErr error + + sourceType := mc.Spec.MetricsEndpoint.SourceType + if sourceType == "" { + sourceType = "prometheus" // default + } + + switch sourceType { + case "prometheus": + if mc.Spec.MetricsEndpoint.PrometheusEndpoint == nil { + err := fmt.Errorf("prometheusEndpoint is required when sourceType is prometheus") + klog.ErrorS(err, "Invalid MetricCollector configuration", "metricCollector", req.NamespacedName) + meta.SetStatusCondition(&mc.Status.Conditions, metav1.Condition{ + Type: placementv1beta1.MetricCollectorConditionTypeReady, + Status: metav1.ConditionFalse, + ObservedGeneration: mc.Generation, + Reason: "InvalidConfiguration", + Message: err.Error(), + }) + if updateErr := r.Status().Update(ctx, mc); updateErr != nil { + klog.ErrorS(updateErr, "Failed to update MetricCollector status", "metricCollector", req.NamespacedName) + return ctrl.Result{}, updateErr + } + return ctrl.Result{RequeueAfter: defaultCollectionInterval}, nil + } + collectedMetrics, collectErr = r.collectFromPrometheus(ctx, mc) + case "direct": + if mc.Spec.MetricsEndpoint.DirectEndpoint == nil { + err := fmt.Errorf("directEndpoint is required when sourceType is direct") + klog.ErrorS(err, "Invalid MetricCollector configuration", "metricCollector", req.NamespacedName) + meta.SetStatusCondition(&mc.Status.Conditions, metav1.Condition{ + Type: placementv1beta1.MetricCollectorConditionTypeReady, + Status: metav1.ConditionFalse, + ObservedGeneration: mc.Generation, + Reason: "InvalidConfiguration", + Message: err.Error(), + }) + if updateErr := r.Status().Update(ctx, mc); updateErr != nil { + klog.ErrorS(updateErr, "Failed to update MetricCollector status", "metricCollector", req.NamespacedName) + return ctrl.Result{}, updateErr + } + return ctrl.Result{RequeueAfter: defaultCollectionInterval}, nil + } + collectedMetrics, collectErr = r.collectDirect(ctx, mc) + default: + err := fmt.Errorf("unsupported source type: %s", sourceType) + klog.ErrorS(err, "Invalid MetricCollector configuration", "metricCollector", req.NamespacedName) + meta.SetStatusCondition(&mc.Status.Conditions, metav1.Condition{ + Type: placementv1beta1.MetricCollectorConditionTypeReady, + Status: metav1.ConditionFalse, + ObservedGeneration: mc.Generation, + Reason: "InvalidConfiguration", + Message: err.Error(), + }) + if updateErr := r.Status().Update(ctx, mc); updateErr != nil { + klog.ErrorS(updateErr, "Failed to update MetricCollector status", "metricCollector", req.NamespacedName) + return ctrl.Result{}, updateErr + } + return ctrl.Result{RequeueAfter: defaultCollectionInterval}, nil + } + + // Update status with collected metrics + now := metav1.Now() + mc.Status.LastCollectionTime = &now + mc.Status.CollectedMetrics = collectedMetrics + mc.Status.WorkloadsMonitored = int32(len(collectedMetrics)) + mc.Status.ObservedGeneration = mc.Generation + + if collectErr != nil { + klog.ErrorS(collectErr, "Failed to collect metrics", "metricCollector", req.NamespacedName, "sourceType", sourceType) + meta.SetStatusCondition(&mc.Status.Conditions, metav1.Condition{ + Type: placementv1beta1.MetricCollectorConditionTypeReady, + Status: metav1.ConditionTrue, + ObservedGeneration: mc.Generation, + Reason: "CollectorConfigured", + Message: "Collector is configured", + }) + meta.SetStatusCondition(&mc.Status.Conditions, metav1.Condition{ + Type: placementv1beta1.MetricCollectorConditionTypeCollecting, + Status: metav1.ConditionFalse, + ObservedGeneration: mc.Generation, + Reason: "CollectionFailed", + Message: fmt.Sprintf("Failed to collect metrics: %v", collectErr), + }) + } else { + klog.V(2).InfoS("Successfully collected metrics", "metricCollector", req.NamespacedName, "workloads", len(collectedMetrics)) + meta.SetStatusCondition(&mc.Status.Conditions, metav1.Condition{ + Type: placementv1beta1.MetricCollectorConditionTypeReady, + Status: metav1.ConditionTrue, + ObservedGeneration: mc.Generation, + Reason: "CollectorConfigured", + Message: "Collector is configured and collecting metrics", + }) + meta.SetStatusCondition(&mc.Status.Conditions, metav1.Condition{ + Type: placementv1beta1.MetricCollectorConditionTypeCollecting, + Status: metav1.ConditionTrue, + ObservedGeneration: mc.Generation, + Reason: "MetricsCollected", + Message: fmt.Sprintf("Successfully collected metrics from %d workloads", len(collectedMetrics)), + }) + } + + if err := r.Status().Update(ctx, mc); err != nil { + klog.ErrorS(err, "Failed to update MetricCollector status", "metricCollector", req.NamespacedName) + return ctrl.Result{}, err + } + + // Requeue after collection interval + return ctrl.Result{RequeueAfter: collectionInterval}, nil +} + +// SetupWithManager sets up the controller with the Manager. +func (r *Reconciler) SetupWithManager(mgr ctrl.Manager) error { + r.recorder = mgr.GetEventRecorderFor("metriccollector-controller") + return ctrl.NewControllerManagedBy(mgr). + Named("metriccollector-controller"). + For(&placementv1beta1.MetricCollector{}, builder.WithPredicates(predicate.GenerationChangedPredicate{})). + Complete(r) +} + +// parseCollectionInterval parses the collection interval string +func parseCollectionInterval(interval string) (time.Duration, error) { + if interval == "" { + return defaultCollectionInterval, nil + } + + duration, err := time.ParseDuration(interval) + if err != nil { + return 0, fmt.Errorf("invalid duration format: %w", err) + } + + if duration < minCollectionInterval { + return 0, fmt.Errorf("collection interval %s is less than minimum %s", duration, minCollectionInterval) + } + + return duration, nil +} diff --git a/test/e2e/kindconfigs/cluster-2.yaml b/test/e2e/kindconfigs/cluster-2.yaml index cbffc7443..84e29acee 100644 --- a/test/e2e/kindconfigs/cluster-2.yaml +++ b/test/e2e/kindconfigs/cluster-2.yaml @@ -7,4 +7,4 @@ apiVersion: kind.x-k8s.io/v1alpha4 nodes: - role: control-plane - role: worker -- role: worker +# - role: worker diff --git a/test/e2e/kindconfigs/cluster-3.yaml b/test/e2e/kindconfigs/cluster-3.yaml index d71759a35..e5eb1328b 100644 --- a/test/e2e/kindconfigs/cluster-3.yaml +++ b/test/e2e/kindconfigs/cluster-3.yaml @@ -7,5 +7,5 @@ apiVersion: kind.x-k8s.io/v1alpha4 nodes: - role: control-plane - role: worker -- role: worker -- role: worker +# - role: worker +# - role: worker diff --git a/tools/prometheus-test/README.md b/tools/prometheus-test/README.md new file mode 100644 index 000000000..10f3d510c --- /dev/null +++ b/tools/prometheus-test/README.md @@ -0,0 +1,69 @@ +# Prometheus Test Tool + +A simple command-line tool to test querying Prometheus API for metrics. + +## Build + +```bash +go build -o prometheus-test main.go +``` + +## Usage + +```bash +./prometheus-test [namespace] +``` + +### Examples + +Query all instances of `workload_health` metric: +```bash +./prometheus-test http://localhost:9090 workload_health +``` + +Query `workload_health` metric filtered by namespace: +```bash +./prometheus-test http://localhost:9090 workload_health test-ns +``` + +Query with port-forward to a Prometheus running in Kubernetes: +```bash +# In one terminal, forward Prometheus port +kubectl port-forward -n monitoring svc/prometheus 9090:9090 + +# In another terminal, query +./prometheus-test http://localhost:9090 workload_health default +``` + +## Output + +The tool will display: +- Query status +- Number of results +- For each result: + - All metric labels (pod, namespace, etc.) + - Timestamp + - Metric value + +## Testing with the Fleet Sample Metric App + +If you have the sample-metric-app deployed: + +```bash +# Port-forward Prometheus +kubectl port-forward -n monitoring svc/prometheus 9090:9090 + +# Query the workload_health metric +./prometheus-test http://localhost:9090 'workload_health{app="sample-metric-app"}' +``` + +## Implementation Notes + +This tool uses the same query approach that will be used in the MetricCollector controller: +1. Builds a Prometheus query URL with `/api/v1/query` endpoint +2. Adds query parameters +3. Makes HTTP GET request with context timeout +4. Parses JSON response +5. Extracts metric labels and values + +The code in this tool can be directly adapted for use in the MetricCollector controller. diff --git a/tools/prometheus-test/main.go b/tools/prometheus-test/main.go new file mode 100644 index 000000000..d8a1447fa --- /dev/null +++ b/tools/prometheus-test/main.go @@ -0,0 +1,127 @@ +package main + +import ( + "context" + "encoding/json" + "fmt" + "io" + "net/http" + "net/url" + "os" + "time" +) + +// PrometheusQueryResult represents the Prometheus API response +type PrometheusQueryResult struct { + Status string `json:"status"` + Data struct { + ResultType string `json:"resultType"` + Result []struct { + Metric map[string]string `json:"metric"` + Value []interface{} `json:"value"` + } `json:"result"` + } `json:"data"` +} + +func main() { + if len(os.Args) < 3 { + fmt.Println("Usage: prometheus-test ") + fmt.Println("Example: prometheus-test http://localhost:9090 workload_health") + os.Exit(1) + } + + prometheusURL := os.Args[1] + metricName := os.Args[2] + + // Build the query - get all instances of the specified metric + query := metricName + + // Optional: filter by namespace if provided + if len(os.Args) > 3 { + namespace := os.Args[3] + query = fmt.Sprintf(`%s{namespace="%s"}`, metricName, namespace) + } + + fmt.Printf("Querying Prometheus at: %s\n", prometheusURL) + fmt.Printf("Query: %s\n", query) + fmt.Println() + + // Query Prometheus + ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second) + defer cancel() + + result, err := queryPrometheus(ctx, prometheusURL, query) + if err != nil { + fmt.Fprintf(os.Stderr, "Error querying Prometheus: %v\n", err) + os.Exit(1) + } + + // Print results + fmt.Printf("Status: %s\n", result.Status) + fmt.Printf("Result Type: %s\n", result.Data.ResultType) + fmt.Printf("Number of results: %d\n", len(result.Data.Result)) + fmt.Println() + + for i, res := range result.Data.Result { + fmt.Printf("Result %d:\n", i+1) + fmt.Printf(" Labels:\n") + for k, v := range res.Metric { + fmt.Printf(" %s: %s\n", k, v) + } + + if len(res.Value) >= 2 { + timestamp := res.Value[0] + value := res.Value[1] + fmt.Printf(" Timestamp: %v\n", timestamp) + fmt.Printf(" Value: %v\n", value) + } + fmt.Println() + } +} + +// queryPrometheus queries the Prometheus HTTP API +func queryPrometheus(ctx context.Context, prometheusURL, query string) (*PrometheusQueryResult, error) { + // Build the query URL + apiURL := fmt.Sprintf("%s/api/v1/query", prometheusURL) + + // Add query parameters + params := url.Values{} + params.Add("query", query) + + fullURL := fmt.Sprintf("%s?%s", apiURL, params.Encode()) + + // Create HTTP request + req, err := http.NewRequestWithContext(ctx, "GET", fullURL, nil) + if err != nil { + return nil, fmt.Errorf("failed to create request: %w", err) + } + + // Execute request + client := &http.Client{ + Timeout: 10 * time.Second, + } + + resp, err := client.Do(req) + if err != nil { + return nil, fmt.Errorf("failed to execute request: %w", err) + } + defer resp.Body.Close() + + // Check status code + if resp.StatusCode != http.StatusOK { + body, _ := io.ReadAll(resp.Body) + return nil, fmt.Errorf("unexpected status code %d: %s", resp.StatusCode, string(body)) + } + + // Parse response + var result PrometheusQueryResult + if err := json.NewDecoder(resp.Body).Decode(&result); err != nil { + return nil, fmt.Errorf("failed to decode response: %w", err) + } + + if result.Status != "success" { + return nil, fmt.Errorf("prometheus query failed with status: %s", result.Status) + } + + return &result, nil +} From 146a416effa17ac493cd9cd1affb5ab29af26d65 Mon Sep 17 00:00:00 2001 From: Arvind Thirumurugan Date: Wed, 19 Nov 2025 15:59:06 -0800 Subject: [PATCH 04/13] simplify metric collector API Signed-off-by: Arvind Thirumurugan --- .../v1beta1/metriccollector_types.go | 163 ++-------------- .../v1beta1/zz_generated.deepcopy.go | 161 +-------------- pkg/controllers/metriccollector/collector.go | 183 ++++-------------- pkg/controllers/metriccollector/controller.go | 114 +---------- tools/prometheus-test/prometheus-test | Bin 0 -> 8247378 bytes 5 files changed, 56 insertions(+), 565 deletions(-) create mode 100755 tools/prometheus-test/prometheus-test diff --git a/apis/placement/v1beta1/metriccollector_types.go b/apis/placement/v1beta1/metriccollector_types.go index cfa9cf01f..94017412b 100644 --- a/apis/placement/v1beta1/metriccollector_types.go +++ b/apis/placement/v1beta1/metriccollector_types.go @@ -52,132 +52,14 @@ type MetricCollector struct { // MetricCollectorSpec defines the desired state of MetricCollector. type MetricCollectorSpec struct { - // WorkloadSelector defines which workloads to monitor. + // PrometheusURL is the URL of the Prometheus server. + // Example: http://prometheus.test-ns.svc.cluster.local:9090 // +required - WorkloadSelector WorkloadSelectorSpec `json:"workloadSelector"` - - // MetricsEndpoint defines how to access the metrics endpoint. - // +required - MetricsEndpoint MetricsEndpointSpec `json:"metricsEndpoint"` - - // CollectionInterval specifies how often to scrape metrics. - // Default is 30s. Minimum is 10s. - // +kubebuilder:default="30s" - // +kubebuilder:validation:Pattern="^([0-9]+(\\.[0-9]+)?(s|m|h))+$" - // +optional - CollectionInterval string `json:"collectionInterval,omitempty"` - - // MetricsToCollect specifies which metrics to collect from the endpoint. - // If empty, specific metrics like workload_health will be collected. - // +optional - // +kubebuilder:validation:MaxItems=50 - MetricsToCollect []string `json:"metricsToCollect,omitempty"` -} - -// WorkloadSelectorSpec defines how to select workloads for monitoring. -type WorkloadSelectorSpec struct { - // LabelSelector to match workloads. - // +required - LabelSelector *metav1.LabelSelector `json:"labelSelector"` - - // Namespaces to monitor. If empty, all namespaces are monitored. - // +optional - // +kubebuilder:validation:MaxItems=100 - Namespaces []string `json:"namespaces,omitempty"` - - // WorkloadTypes specifies which types of workloads to monitor. - // Supported: Deployment, StatefulSet, DaemonSet, Pod. - // If empty, only Pods are monitored. - // +optional - // +kubebuilder:validation:MaxItems=10 - WorkloadTypes []string `json:"workloadTypes,omitempty"` -} - -// MetricsEndpointSpec defines how to access the metrics endpoint. -type MetricsEndpointSpec struct { - // SourceType defines the type of metrics source. - // "prometheus" - Query a centralized Prometheus server (recommended for production) - // "direct" - Directly scrape each pod's metrics endpoint - // Default is "prometheus". - // +kubebuilder:validation:Enum=prometheus;direct - // +kubebuilder:default="prometheus" - // +optional - SourceType string `json:"sourceType,omitempty"` - - // PrometheusEndpoint specifies the Prometheus server to query. - // Required when SourceType is "prometheus". - // +optional - PrometheusEndpoint *PrometheusEndpointSpec `json:"prometheusEndpoint,omitempty"` - - // DirectEndpoint specifies how to scrape pods directly. - // Required when SourceType is "direct". - // +optional - DirectEndpoint *DirectEndpointSpec `json:"directEndpoint,omitempty"` -} - -// PrometheusEndpointSpec defines how to connect to a Prometheus server. -type PrometheusEndpointSpec struct { - // URL of the Prometheus server. - // Example: http://prometheus-server.monitoring:9090 - // +kubebuilder:validation:Required // +kubebuilder:validation:Pattern=`^https?://.*$` - URL string `json:"url"` - - // Auth specifies authentication configuration for Prometheus. - // +optional - Auth *PrometheusAuthConfig `json:"auth,omitempty"` -} - -// PrometheusAuthConfig specifies authentication for Prometheus. -type PrometheusAuthConfig struct { - // Type of authentication (bearer or basic). - // +kubebuilder:validation:Enum=bearer;basic - // +optional - Type string `json:"type,omitempty"` - - // SecretRef references a secret containing authentication credentials. - // For bearer: key "token" - // For basic: keys "username" and "password" - // +optional - SecretRef *SecretReference `json:"secretRef,omitempty"` -} - -// SecretReference identifies a secret. -type SecretReference struct { - // Name of the secret. - // +kubebuilder:validation:Required - // +kubebuilder:validation:MaxLength=253 - Name string `json:"name"` - - // Namespace of the secret. - // If not specified, the namespace of the MetricCollector will be used. - // +optional - Namespace string `json:"namespace,omitempty"` -} - -// DirectEndpointSpec defines how to scrape pods directly. -type DirectEndpointSpec struct { - // Port where metrics are exposed on pods. - // +kubebuilder:validation:Minimum=1 - // +kubebuilder:validation:Maximum=65535 - // +required - Port int32 `json:"port"` - - // Path to the metrics endpoint. - // Default is "/metrics". - // +kubebuilder:default="/metrics" - // +optional - Path string `json:"path,omitempty"` - - // Scheme for the metrics endpoint (http or https). - // Default is "http". - // +kubebuilder:default="http" - // +kubebuilder:validation:Enum=http;https - // +optional - Scheme string `json:"scheme,omitempty"` + PrometheusURL string `json:"prometheusUrl"` } -// MetricCollectorStatus defines the observed state of MetricCollector. +// MetricsEndpointSpec defines how to access the metrics endpoint.ctor. type MetricCollectorStatus struct { // Conditions is an array of current observed conditions. // +optional @@ -200,40 +82,23 @@ type MetricCollectorStatus struct { CollectedMetrics []WorkloadMetrics `json:"collectedMetrics,omitempty"` } -// WorkloadMetrics represents metrics collected from a single workload. +// WorkloadMetrics represents metrics collected from a single workload pod. type WorkloadMetrics struct { - // WorkloadName is the name of the workload. - // +required - Name string `json:"name"` - - // WorkloadNamespace is the namespace of the workload. + // Namespace is the namespace of the pod. // +required Namespace string `json:"namespace"` - // WorkloadKind is the kind of workload (Pod, Deployment, etc.). + // ClusterName from the workload_health metric label. // +required - Kind string `json:"kind"` - - // Metrics contains the collected metric values. - // Key is metric name, value is the metric value. - // +optional - Metrics map[string]string `json:"metrics,omitempty"` - - // Labels from the metric (like cluster_name, workload_name from the app). - // +optional - Labels map[string]string `json:"labels,omitempty"` + ClusterName string `json:"clusterName"` - // LastScrapedTime is when metrics were last scraped from this workload. - // +optional - LastScrapedTime *metav1.Time `json:"lastScrapedTime,omitempty"` - - // Healthy indicates if the workload is healthy based on metrics. - // +optional - Healthy *bool `json:"healthy,omitempty"` + // WorkloadName from the workload_health metric label (typically the deployment name). + // +required + WorkloadName string `json:"workloadName"` - // ErrorMessage if scraping failed. - // +optional - ErrorMessage string `json:"errorMessage,omitempty"` + // Health is the value of workload_health metric (1=healthy, 0=unhealthy). + // +required + Health float64 `json:"health"` } const ( diff --git a/apis/placement/v1beta1/zz_generated.deepcopy.go b/apis/placement/v1beta1/zz_generated.deepcopy.go index 011fd7b68..999a76be2 100644 --- a/apis/placement/v1beta1/zz_generated.deepcopy.go +++ b/apis/placement/v1beta1/zz_generated.deepcopy.go @@ -1336,21 +1336,6 @@ func (in *DiffedResourcePlacement) DeepCopy() *DiffedResourcePlacement { return out } -// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. -func (in *DirectEndpointSpec) DeepCopyInto(out *DirectEndpointSpec) { - *out = *in -} - -// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new DirectEndpointSpec. -func (in *DirectEndpointSpec) DeepCopy() *DirectEndpointSpec { - if in == nil { - return nil - } - out := new(DirectEndpointSpec) - in.DeepCopyInto(out) - return out -} - // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *DriftDetails) DeepCopyInto(out *DriftDetails) { *out = *in @@ -1503,7 +1488,7 @@ func (in *MetricCollector) DeepCopyInto(out *MetricCollector) { *out = *in out.TypeMeta = in.TypeMeta in.ObjectMeta.DeepCopyInto(&out.ObjectMeta) - in.Spec.DeepCopyInto(&out.Spec) + out.Spec = in.Spec in.Status.DeepCopyInto(&out.Status) } @@ -1560,13 +1545,6 @@ func (in *MetricCollectorList) DeepCopyObject() runtime.Object { // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *MetricCollectorSpec) DeepCopyInto(out *MetricCollectorSpec) { *out = *in - in.WorkloadSelector.DeepCopyInto(&out.WorkloadSelector) - in.MetricsEndpoint.DeepCopyInto(&out.MetricsEndpoint) - if in.MetricsToCollect != nil { - in, out := &in.MetricsToCollect, &out.MetricsToCollect - *out = make([]string, len(*in)) - copy(*out, *in) - } } // DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MetricCollectorSpec. @@ -1596,9 +1574,7 @@ func (in *MetricCollectorStatus) DeepCopyInto(out *MetricCollectorStatus) { if in.CollectedMetrics != nil { in, out := &in.CollectedMetrics, &out.CollectedMetrics *out = make([]WorkloadMetrics, len(*in)) - for i := range *in { - (*in)[i].DeepCopyInto(&(*out)[i]) - } + copy(*out, *in) } } @@ -1612,31 +1588,6 @@ func (in *MetricCollectorStatus) DeepCopy() *MetricCollectorStatus { return out } -// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. -func (in *MetricsEndpointSpec) DeepCopyInto(out *MetricsEndpointSpec) { - *out = *in - if in.PrometheusEndpoint != nil { - in, out := &in.PrometheusEndpoint, &out.PrometheusEndpoint - *out = new(PrometheusEndpointSpec) - (*in).DeepCopyInto(*out) - } - if in.DirectEndpoint != nil { - in, out := &in.DirectEndpoint, &out.DirectEndpoint - *out = new(DirectEndpointSpec) - **out = **in - } -} - -// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MetricsEndpointSpec. -func (in *MetricsEndpointSpec) DeepCopy() *MetricsEndpointSpec { - if in == nil { - return nil - } - out := new(MetricsEndpointSpec) - in.DeepCopyInto(out) - return out -} - // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *NamespacedName) DeepCopyInto(out *NamespacedName) { *out = *in @@ -1973,46 +1924,6 @@ func (in *PreferredClusterSelector) DeepCopy() *PreferredClusterSelector { return out } -// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. -func (in *PrometheusAuthConfig) DeepCopyInto(out *PrometheusAuthConfig) { - *out = *in - if in.SecretRef != nil { - in, out := &in.SecretRef, &out.SecretRef - *out = new(SecretReference) - **out = **in - } -} - -// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PrometheusAuthConfig. -func (in *PrometheusAuthConfig) DeepCopy() *PrometheusAuthConfig { - if in == nil { - return nil - } - out := new(PrometheusAuthConfig) - in.DeepCopyInto(out) - return out -} - -// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. -func (in *PrometheusEndpointSpec) DeepCopyInto(out *PrometheusEndpointSpec) { - *out = *in - if in.Auth != nil { - in, out := &in.Auth, &out.Auth - *out = new(PrometheusAuthConfig) - (*in).DeepCopyInto(*out) - } -} - -// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PrometheusEndpointSpec. -func (in *PrometheusEndpointSpec) DeepCopy() *PrometheusEndpointSpec { - if in == nil { - return nil - } - out := new(PrometheusEndpointSpec) - in.DeepCopyInto(out) - return out -} - // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *PropertySelector) DeepCopyInto(out *PropertySelector) { *out = *in @@ -2865,21 +2776,6 @@ func (in *SchedulingPolicySnapshotStatus) DeepCopy() *SchedulingPolicySnapshotSt return out } -// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. -func (in *SecretReference) DeepCopyInto(out *SecretReference) { - *out = *in -} - -// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new SecretReference. -func (in *SecretReference) DeepCopy() *SecretReference { - if in == nil { - return nil - } - out := new(SecretReference) - in.DeepCopyInto(out) - return out -} - // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *ServerSideApplyConfig) DeepCopyInto(out *ServerSideApplyConfig) { *out = *in @@ -3397,29 +3293,6 @@ func (in *WorkStatus) DeepCopy() *WorkStatus { // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *WorkloadMetrics) DeepCopyInto(out *WorkloadMetrics) { *out = *in - if in.Metrics != nil { - in, out := &in.Metrics, &out.Metrics - *out = make(map[string]string, len(*in)) - for key, val := range *in { - (*out)[key] = val - } - } - if in.Labels != nil { - in, out := &in.Labels, &out.Labels - *out = make(map[string]string, len(*in)) - for key, val := range *in { - (*out)[key] = val - } - } - if in.LastScrapedTime != nil { - in, out := &in.LastScrapedTime, &out.LastScrapedTime - *out = (*in).DeepCopy() - } - if in.Healthy != nil { - in, out := &in.Healthy, &out.Healthy - *out = new(bool) - **out = **in - } } // DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new WorkloadMetrics. @@ -3432,36 +3305,6 @@ func (in *WorkloadMetrics) DeepCopy() *WorkloadMetrics { return out } -// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. -func (in *WorkloadSelectorSpec) DeepCopyInto(out *WorkloadSelectorSpec) { - *out = *in - if in.LabelSelector != nil { - in, out := &in.LabelSelector, &out.LabelSelector - *out = new(v1.LabelSelector) - (*in).DeepCopyInto(*out) - } - if in.Namespaces != nil { - in, out := &in.Namespaces, &out.Namespaces - *out = make([]string, len(*in)) - copy(*out, *in) - } - if in.WorkloadTypes != nil { - in, out := &in.WorkloadTypes, &out.WorkloadTypes - *out = make([]string, len(*in)) - copy(*out, *in) - } -} - -// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new WorkloadSelectorSpec. -func (in *WorkloadSelectorSpec) DeepCopy() *WorkloadSelectorSpec { - if in == nil { - return nil - } - out := new(WorkloadSelectorSpec) - in.DeepCopyInto(out) - return out -} - // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *WorkloadTemplate) DeepCopyInto(out *WorkloadTemplate) { *out = *in diff --git a/pkg/controllers/metriccollector/collector.go b/pkg/controllers/metriccollector/collector.go index de9925a73..35b6d66d1 100644 --- a/pkg/controllers/metriccollector/collector.go +++ b/pkg/controllers/metriccollector/collector.go @@ -28,7 +28,6 @@ import ( "time" corev1 "k8s.io/api/core/v1" - "k8s.io/apimachinery/pkg/types" "k8s.io/klog/v2" placementv1beta1 "github.com/kubefleet-dev/kubefleet/apis/placement/v1beta1" @@ -151,174 +150,60 @@ type PrometheusResult struct { Value []interface{} `json:"value"` // [timestamp, value] } -// MetricsCollector is the interface for collecting metrics from pods -type MetricsCollector interface { - CollectFromPods(ctx context.Context, mc *placementv1beta1.MetricCollector) ([]placementv1beta1.WorkloadMetrics, error) -} - // collectFromPrometheus collects metrics from a Prometheus endpoint func (r *Reconciler) collectFromPrometheus(ctx context.Context, mc *placementv1beta1.MetricCollector) ([]placementv1beta1.WorkloadMetrics, error) { - promEndpoint := mc.Spec.MetricsEndpoint.PrometheusEndpoint - if promEndpoint == nil { - return nil, fmt.Errorf("prometheusEndpoint is nil") - } + // Create Prometheus client without auth (simplified) + promClient := NewPrometheusClient(mc.Spec.PrometheusURL, "", nil) - // Fetch authentication secret if configured - var authSecret *corev1.Secret - if promEndpoint.Auth != nil && promEndpoint.Auth.SecretRef != nil { - secret := &corev1.Secret{} - secretName := types.NamespacedName{ - Name: promEndpoint.Auth.SecretRef.Name, - Namespace: mc.Namespace, - } - if err := r.Get(ctx, secretName, secret); err != nil { - return nil, fmt.Errorf("failed to get auth secret: %w", err) - } - authSecret = secret - } + // Build PromQL query for workload_health metric with label selector + query := buildPromQLQuery(mc) + klog.V(4).InfoS("Executing PromQL query", "query", query) - // Create Prometheus client - authType := "" - if promEndpoint.Auth != nil { - authType = promEndpoint.Auth.Type + result, err := promClient.Query(ctx, query) + if err != nil { + return nil, fmt.Errorf("failed to query Prometheus: %w", err) } - promClient := NewPrometheusClient(promEndpoint.URL, authType, authSecret) - // Build PromQL query from workloadSelector and metricsToCollect - queries := buildPromQLQueries(mc) - if len(queries) == 0 { - return nil, fmt.Errorf("no metrics to collect") + // Parse Prometheus response + data, ok := result.(PrometheusData) + if !ok { + return nil, fmt.Errorf("invalid Prometheus response type") } - // Collect metrics for each query - workloadMetricsMap := make(map[string]*placementv1beta1.WorkloadMetrics) - - for metricName, query := range queries { - klog.V(4).InfoS("Executing PromQL query", "metric", metricName, "query", query) - result, err := promClient.Query(ctx, query) - if err != nil { - klog.ErrorS(err, "Failed to query Prometheus", "metric", metricName, "query", query) - continue - } + // Extract metrics for each workload + workloadMetrics := make([]placementv1beta1.WorkloadMetrics, 0, len(data.Result)) + for _, res := range data.Result { + namespace := res.Metric["namespace"] + clusterName := res.Metric["cluster_name"] + workloadName := res.Metric["workload_name"] - // Parse Prometheus response - data, ok := result.(PrometheusData) - if !ok { - klog.ErrorS(nil, "Invalid Prometheus response type", "metric", metricName) + if namespace == "" || clusterName == "" || workloadName == "" { continue } - // Extract metrics for each workload - for _, res := range data.Result { - workloadKey := buildWorkloadKey(res.Metric) - if workloadKey == "" { - continue - } - - // Get or create workload metrics entry - if _, exists := workloadMetricsMap[workloadKey]; !exists { - workloadMetricsMap[workloadKey] = &placementv1beta1.WorkloadMetrics{ - Name: res.Metric["pod"], - Namespace: res.Metric["namespace"], - Kind: getWorkloadKind(res.Metric), - Metrics: make(map[string]string), - } - } - - // Extract metric value - if len(res.Value) >= 2 { - if value, ok := res.Value[1].(string); ok { - workloadMetricsMap[workloadKey].Metrics[metricName] = value - } + // Extract health value + var health float64 + if len(res.Value) >= 2 { + if valueStr, ok := res.Value[1].(string); ok { + fmt.Sscanf(valueStr, "%f", &health) } } - } - // Convert map to slice - workloadMetrics := make([]placementv1beta1.WorkloadMetrics, 0, len(workloadMetricsMap)) - for _, wm := range workloadMetricsMap { - // Set health status based on workload_health metric if present - if healthValue, ok := wm.Metrics["workload_health"]; ok { - healthy := false - if healthValue == "1" || healthValue == "1.0" { - healthy = true - } - wm.Healthy = &healthy + wm := placementv1beta1.WorkloadMetrics{ + Namespace: namespace, + ClusterName: clusterName, + WorkloadName: workloadName, + Health: health, } - workloadMetrics = append(workloadMetrics, *wm) + workloadMetrics = append(workloadMetrics, wm) } klog.V(2).InfoS("Collected metrics from Prometheus", "workloads", len(workloadMetrics)) return workloadMetrics, nil } -// buildPromQLQueries builds PromQL queries based on workloadSelector and metricsToCollect -func buildPromQLQueries(mc *placementv1beta1.MetricCollector) map[string]string { - queries := make(map[string]string) - selector := mc.Spec.WorkloadSelector - - // Build label selector string - labelSelectors := []string{} - if selector.LabelSelector != nil { - for key, value := range selector.LabelSelector.MatchLabels { - labelSelectors = append(labelSelectors, fmt.Sprintf(`%s="%s"`, key, value)) - } - } - - // Add namespace filter if specified - if len(selector.Namespaces) > 0 { - namespaceFilter := strings.Join(selector.Namespaces, "|") - labelSelectors = append(labelSelectors, fmt.Sprintf(`namespace=~"%s"`, namespaceFilter)) - } - - labelSelectorStr := strings.Join(labelSelectors, ",") - - // Build query for each metric - for _, metricName := range mc.Spec.MetricsToCollect { - if labelSelectorStr != "" { - queries[metricName] = fmt.Sprintf("%s{%s}", metricName, labelSelectorStr) - } else { - queries[metricName] = metricName - } - } - - return queries -} - -// buildWorkloadKey creates a unique key for a workload from metric labels -func buildWorkloadKey(labels map[string]string) string { - namespace := labels["namespace"] - pod := labels["pod"] - if namespace == "" || pod == "" { - return "" - } - return fmt.Sprintf("%s/%s", namespace, pod) -} - -// getWorkloadKind attempts to determine the workload kind from metric labels -func getWorkloadKind(labels map[string]string) string { - // Try common Kubernetes labels - if kind := labels["kind"]; kind != "" { - return kind - } - if labels["deployment"] != "" { - return "Deployment" - } - if labels["statefulset"] != "" { - return "StatefulSet" - } - if labels["daemonset"] != "" { - return "DaemonSet" - } - return "Pod" // Default to Pod if unable to determine -} - -// collectDirect collects metrics by directly scraping pod endpoints -func (r *Reconciler) collectDirect(ctx context.Context, mc *placementv1beta1.MetricCollector) ([]placementv1beta1.WorkloadMetrics, error) { - // TODO: Implement direct pod scraping logic - // 1. List pods using workloadSelector - // 2. For each pod, scrape metrics endpoint - // 3. Parse Prometheus text format - // 4. Return WorkloadMetrics array - return nil, nil +// buildPromQLQuery builds a PromQL query for workload_health metric +func buildPromQLQuery(mc *placementv1beta1.MetricCollector) string { + // Query all workload_health metrics in the MetricCollector's namespace + return fmt.Sprintf(`workload_health{namespace="%s"}`, mc.Namespace) } diff --git a/pkg/controllers/metriccollector/controller.go b/pkg/controllers/metriccollector/controller.go index 6ff5c6806..d165cf16a 100644 --- a/pkg/controllers/metriccollector/controller.go +++ b/pkg/controllers/metriccollector/controller.go @@ -35,11 +35,8 @@ import ( ) const ( - // defaultCollectionInterval is the default interval for collecting metrics + // defaultCollectionInterval is the interval for collecting metrics (30 seconds) defaultCollectionInterval = 30 * time.Second - - // minCollectionInterval is the minimum allowed interval for collecting metrics - minCollectionInterval = 10 * time.Second ) // Reconciler reconciles a MetricCollector object @@ -52,9 +49,6 @@ type Reconciler struct { // prometheusClient is the client to query Prometheus prometheusClient PrometheusClient - - // metricsCollector collects metrics from pods - metricsCollector MetricsCollector } // Reconcile reconciles a MetricCollector object @@ -77,86 +71,8 @@ func (r *Reconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Resu return ctrl.Result{}, err } - // Parse collection interval - collectionInterval, err := parseCollectionInterval(mc.Spec.CollectionInterval) - if err != nil { - klog.ErrorS(err, "Invalid collection interval", "metricCollector", req.NamespacedName, "interval", mc.Spec.CollectionInterval) - meta.SetStatusCondition(&mc.Status.Conditions, metav1.Condition{ - Type: placementv1beta1.MetricCollectorConditionTypeReady, - Status: metav1.ConditionFalse, - ObservedGeneration: mc.Generation, - Reason: "InvalidConfiguration", - Message: fmt.Sprintf("Invalid collection interval: %v", err), - }) - if updateErr := r.Status().Update(ctx, mc); updateErr != nil { - klog.ErrorS(updateErr, "Failed to update MetricCollector status", "metricCollector", req.NamespacedName) - return ctrl.Result{}, updateErr - } - return ctrl.Result{RequeueAfter: defaultCollectionInterval}, nil - } - - // Collect metrics based on source type - var collectedMetrics []placementv1beta1.WorkloadMetrics - var collectErr error - - sourceType := mc.Spec.MetricsEndpoint.SourceType - if sourceType == "" { - sourceType = "prometheus" // default - } - - switch sourceType { - case "prometheus": - if mc.Spec.MetricsEndpoint.PrometheusEndpoint == nil { - err := fmt.Errorf("prometheusEndpoint is required when sourceType is prometheus") - klog.ErrorS(err, "Invalid MetricCollector configuration", "metricCollector", req.NamespacedName) - meta.SetStatusCondition(&mc.Status.Conditions, metav1.Condition{ - Type: placementv1beta1.MetricCollectorConditionTypeReady, - Status: metav1.ConditionFalse, - ObservedGeneration: mc.Generation, - Reason: "InvalidConfiguration", - Message: err.Error(), - }) - if updateErr := r.Status().Update(ctx, mc); updateErr != nil { - klog.ErrorS(updateErr, "Failed to update MetricCollector status", "metricCollector", req.NamespacedName) - return ctrl.Result{}, updateErr - } - return ctrl.Result{RequeueAfter: defaultCollectionInterval}, nil - } - collectedMetrics, collectErr = r.collectFromPrometheus(ctx, mc) - case "direct": - if mc.Spec.MetricsEndpoint.DirectEndpoint == nil { - err := fmt.Errorf("directEndpoint is required when sourceType is direct") - klog.ErrorS(err, "Invalid MetricCollector configuration", "metricCollector", req.NamespacedName) - meta.SetStatusCondition(&mc.Status.Conditions, metav1.Condition{ - Type: placementv1beta1.MetricCollectorConditionTypeReady, - Status: metav1.ConditionFalse, - ObservedGeneration: mc.Generation, - Reason: "InvalidConfiguration", - Message: err.Error(), - }) - if updateErr := r.Status().Update(ctx, mc); updateErr != nil { - klog.ErrorS(updateErr, "Failed to update MetricCollector status", "metricCollector", req.NamespacedName) - return ctrl.Result{}, updateErr - } - return ctrl.Result{RequeueAfter: defaultCollectionInterval}, nil - } - collectedMetrics, collectErr = r.collectDirect(ctx, mc) - default: - err := fmt.Errorf("unsupported source type: %s", sourceType) - klog.ErrorS(err, "Invalid MetricCollector configuration", "metricCollector", req.NamespacedName) - meta.SetStatusCondition(&mc.Status.Conditions, metav1.Condition{ - Type: placementv1beta1.MetricCollectorConditionTypeReady, - Status: metav1.ConditionFalse, - ObservedGeneration: mc.Generation, - Reason: "InvalidConfiguration", - Message: err.Error(), - }) - if updateErr := r.Status().Update(ctx, mc); updateErr != nil { - klog.ErrorS(updateErr, "Failed to update MetricCollector status", "metricCollector", req.NamespacedName) - return ctrl.Result{}, updateErr - } - return ctrl.Result{RequeueAfter: defaultCollectionInterval}, nil - } + // Collect metrics from Prometheus + collectedMetrics, collectErr := r.collectFromPrometheus(ctx, mc) // Update status with collected metrics now := metav1.Now() @@ -166,7 +82,7 @@ func (r *Reconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Resu mc.Status.ObservedGeneration = mc.Generation if collectErr != nil { - klog.ErrorS(collectErr, "Failed to collect metrics", "metricCollector", req.NamespacedName, "sourceType", sourceType) + klog.ErrorS(collectErr, "Failed to collect metrics", "metricCollector", req.NamespacedName) meta.SetStatusCondition(&mc.Status.Conditions, metav1.Condition{ Type: placementv1beta1.MetricCollectorConditionTypeReady, Status: metav1.ConditionTrue, @@ -204,8 +120,8 @@ func (r *Reconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Resu return ctrl.Result{}, err } - // Requeue after collection interval - return ctrl.Result{RequeueAfter: collectionInterval}, nil + // Requeue after 30 seconds + return ctrl.Result{RequeueAfter: defaultCollectionInterval}, nil } // SetupWithManager sets up the controller with the Manager. @@ -216,21 +132,3 @@ func (r *Reconciler) SetupWithManager(mgr ctrl.Manager) error { For(&placementv1beta1.MetricCollector{}, builder.WithPredicates(predicate.GenerationChangedPredicate{})). Complete(r) } - -// parseCollectionInterval parses the collection interval string -func parseCollectionInterval(interval string) (time.Duration, error) { - if interval == "" { - return defaultCollectionInterval, nil - } - - duration, err := time.ParseDuration(interval) - if err != nil { - return 0, fmt.Errorf("invalid duration format: %w", err) - } - - if duration < minCollectionInterval { - return 0, fmt.Errorf("collection interval %s is less than minimum %s", duration, minCollectionInterval) - } - - return duration, nil -} diff --git a/tools/prometheus-test/prometheus-test b/tools/prometheus-test/prometheus-test new file mode 100755 index 0000000000000000000000000000000000000000..19bdced7acd021464b1a2d66bdc7d9a7fa63b24a GIT binary patch literal 8247378 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 D1usTy`edfplEF6*mjuF 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