github/kubernetes
1
0
Fork 0
mirror of https://github.com/k3s-io/kubernetes.git synced 2025-07-22 19:31:44 +00:00
Code Issues Projects Releases Wiki Activity

Remove known metrics list

Browse Source
This commit is contained in:
gmarek 2016-06-13 10:37:21 +02:00
parent 875a60d030
commit 0adcc8ef1e
8 changed files with 28 additions and 329 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

40
pkg/metrics/api_server_metrics.go
View File

@ -16,39 +16,6 @@ limitations under the License.
package metrics
import (
"k8s.io/kubernetes/pkg/util/sets"
"github.com/prometheus/common/model"
)
var KnownApiServerMetrics = map[string][]string{
"apiserver_request_count": {"verb", "resource", "client", "contentType", "code"},
"apiserver_request_latencies_bucket": {"verb", "resource", "le"},
"apiserver_request_latencies_count": {"verb", "resource"},
"apiserver_request_latencies_sum": {"verb", "resource"},
"apiserver_request_latencies_summary": {"verb", "resource", "quantile"},
"apiserver_request_latencies_summary_count": {"verb", "resource"},
"apiserver_request_latencies_summary_sum": {"verb", "resource"},
"authenticated_user_requests": {"username"},
"etcd_helper_cache_entry_count": {},
"etcd_helper_cache_hit_count": {},
"etcd_helper_cache_miss_count": {},
"etcd_request_cache_add_latencies_summary": {"quantile"},
"etcd_request_cache_add_latencies_summary_count": {},
"etcd_request_cache_add_latencies_summary_sum": {},
"etcd_request_cache_get_latencies_summary": {"quantile"},
"etcd_request_cache_get_latencies_summary_count": {},
"etcd_request_cache_get_latencies_summary_sum": {},
"etcd_request_latencies_summary": {"operation", "type", "quantile"},
"etcd_request_latencies_summary_count": {"operation", "type"},
"etcd_request_latencies_summary_sum": {"operation", "type"},
"rest_client_request_latency_microseconds": {"url", "verb", "quantile"},
"rest_client_request_latency_microseconds_count": {"url", "verb"},
"rest_client_request_latency_microseconds_sum": {"url", "verb"},
"rest_client_request_status_codes": {"code", "host", "method"},
}
type ApiServerMetrics Metrics
func (m *ApiServerMetrics) Equal(o ApiServerMetrics) bool {
@ -57,15 +24,12 @@ func (m *ApiServerMetrics) Equal(o ApiServerMetrics) bool {
func NewApiServerMetrics() ApiServerMetrics {
result := NewMetrics()
for metric := range KnownApiServerMetrics {
result[metric] = make(model.Samples, 0)
}
return ApiServerMetrics(result)
}
func parseApiServerMetrics(data string, unknownMetrics sets.String) (ApiServerMetrics, error) {
func parseApiServerMetrics(data string) (ApiServerMetrics, error) {
result := NewApiServerMetrics()
if err := parseMetrics(data, KnownApiServerMetrics, (*Metrics)(&result), unknownMetrics); err != nil {
if err := parseMetrics(data, (*Metrics)(&result)); err != nil {
return ApiServerMetrics{}, err
}
return result, nil

47
pkg/metrics/controller_manager_metrics.go
View File

@ -16,46 +16,6 @@ limitations under the License.
package metrics
import (
"k8s.io/kubernetes/pkg/util/sets"
"github.com/prometheus/common/model"
)
var KnownControllerManagerMetrics = map[string][]string{
"etcd_helper_cache_entry_count": {},
"etcd_helper_cache_hit_count": {},
"etcd_helper_cache_miss_count": {},
"etcd_request_cache_add_latencies_summary": {"quantile"},
"etcd_request_cache_add_latencies_summary_count": {},
"etcd_request_cache_add_latencies_summary_sum": {},
"etcd_request_cache_get_latencies_summary": {"quantile"},
"etcd_request_cache_get_latencies_summary_count": {},
"etcd_request_cache_get_latencies_summary_sum": {},
"get_token_count": {},
"get_token_fail_count": {},
"rest_client_request_latency_microseconds": {"url", "verb", "quantile"},
"rest_client_request_latency_microseconds_count": {"url", "verb"},
"rest_client_request_latency_microseconds_sum": {"url", "verb"},
"rest_client_request_status_codes": {"method", "code", "host"},
"pv_recycler_controller_rate_limiter_use": {},
"node_controller_rate_limiter_use": {},
"serviceaccount_controller_rate_limiter_use": {},
"route_controller_rate_limiter_use": {},
"resource_quota_controller_rate_limiter_use": {},
"replenishment_controller_rate_limiter_use": {},
"job_controller_rate_limiter_use": {},
"gc_controller_rate_limiter_use": {},
"endpoint_controller_rate_limiter_use": {},
"replication_controller_rate_limiter_use": {},
"replicaset_controller_rate_limiter_use": {},
"deployment_controller_rate_limiter_use": {},
"service_controller_rate_limiter_use": {},
"pv_claim_binder_controller_rate_limiter_use": {},
"namespace_controller_rate_limiter_use": {},
"daemon_controller_rate_limiter_use": {},
}
type ControllerManagerMetrics Metrics
func (m *ControllerManagerMetrics) Equal(o ControllerManagerMetrics) bool {
@ -64,15 +24,12 @@ func (m *ControllerManagerMetrics) Equal(o ControllerManagerMetrics) bool {
func NewControllerManagerMetrics() ControllerManagerMetrics {
result := NewMetrics()
for metric := range KnownControllerManagerMetrics {
result[metric] = make(model.Samples, 0)
}
return ControllerManagerMetrics(result)
}
func parseControllerManagerMetrics(data string, unknownMetrics sets.String) (ControllerManagerMetrics, error) {
func parseControllerManagerMetrics(data string) (ControllerManagerMetrics, error) {
result := NewControllerManagerMetrics()
if err := parseMetrics(data, KnownControllerManagerMetrics, (*Metrics)(&result), unknownMetrics); err != nil {
if err := parseMetrics(data, (*Metrics)(&result)); err != nil {
return ControllerManagerMetrics{}, err
}
return result, nil

47
pkg/metrics/generic_metrics.go
View File

@ -22,41 +22,11 @@ import (
"reflect"
"strings"
"k8s.io/kubernetes/pkg/util/sets"
"github.com/golang/glog"
"github.com/prometheus/common/expfmt"
"github.com/prometheus/common/model"
)
var CommonMetrics = map[string][]string{
"get_token_count": {},
"get_token_fail_count": {},
"go_gc_duration_seconds": {"quantile"},
"go_gc_duration_seconds_count": {},
"go_gc_duration_seconds_sum": {},
"go_goroutines": {},
"http_request_duration_microseconds": {"handler", "quantile"},
"http_request_duration_microseconds_count": {"handler"},
"http_request_duration_microseconds_sum": {"handler"},
"http_request_size_bytes": {"handler", "quantile"},
"http_request_size_bytes_count": {"handler"},
"http_request_size_bytes_sum": {"handler"},
"http_requests_total": {"handler", "method", "code"},
"http_response_size_bytes": {"handler", "quantile"},
"http_response_size_bytes_count": {"handler"},
"http_response_size_bytes_sum": {"handler"},
"kubernetes_build_info": {"major", "minor", "gitCommit", "gitTreeState", "gitVersion", "buildDate", "goVersion", "compiler", "platform"},
"process_cpu_seconds_total": {},
"process_max_fds": {},
"process_open_fds": {},
"process_resident_memory_bytes": {},
"process_start_time_seconds": {},
"process_virtual_memory_bytes": {},
"ssh_tunnel_open_count": {},
"ssh_tunnel_open_fail_count": {},
}
type Metrics map[string]model.Samples
func (m *Metrics) Equal(o Metrics) bool {
@ -87,7 +57,7 @@ func PrintSample(sample *model.Sample) string {
// but it works...
_, normalContainer := sample.Metric["kubernetes_container_name"]
for k, v := range sample.Metric {
if strings.HasPrefix(string(k), "__") || KubeletMetricsLabelsToSkip.Has(string(k)) {
if strings.HasPrefix(string(k), "__") {
continue
}
@ -101,13 +71,10 @@ func PrintSample(sample *model.Sample) string {
func NewMetrics() Metrics {
result := make(Metrics)
for metric := range CommonMetrics {
result[metric] = make(model.Samples, 0)
}
return result
}
func parseMetrics(data string, knownMetrics map[string][]string, output *Metrics, unknownMetrics sets.String) error {
func parseMetrics(data string, output *Metrics) error {
dec := expfmt.NewDecoder(strings.NewReader(data), expfmt.FmtText)
decoder := expfmt.SampleDecoder{
Dec: dec,
@ -126,15 +93,7 @@ func parseMetrics(data string, knownMetrics map[string][]string, output *Metrics
}
for _, metric := range v {
name := string(metric.Metric[model.MetricNameLabel])
_, isCommonMetric := CommonMetrics[name]
_, isKnownMetric := knownMetrics[name]
if isKnownMetric || isCommonMetric {
(*output)[name] = append((*output)[name], metric)
} else {
if unknownMetrics != nil {
unknownMetrics.Insert(name)
}
}
(*output)[name] = append((*output)[name], metric)
}
}
}

98
pkg/metrics/kubelet_metrics.go
View File

@ -21,99 +21,6 @@ import (
"io/ioutil"
"net/http"
"time"
"k8s.io/kubernetes/pkg/util/sets"
"github.com/prometheus/common/model"
)
var NecessaryKubeletMetrics = map[string][]string{
"cadvisor_version_info": {"cadvisorRevision", "cadvisorVersion", "dockerVersion", "kernelVersion", "osVersion"},
"container_cpu_system_seconds_total": {"id", "image", "kubernetes_container_name", "kubernetes_namespace", "kubernetes_pod_name", "name"},
"container_cpu_usage_seconds_total": {"id", "image", "kubernetes_container_name", "kubernetes_namespace", "kubernetes_pod_name", "name", "cpu"},
"container_cpu_user_seconds_total": {"id", "image", "kubernetes_container_name", "kubernetes_namespace", "kubernetes_pod_name", "name"},
"container_fs_io_current": {"device", "id", "image", "kubernetes_container_name", "kubernetes_namespace", "kubernetes_pod_name", "name"},
"container_fs_io_time_seconds_total": {"device", "id", "image", "kubernetes_container_name", "kubernetes_namespace", "kubernetes_pod_name", "name"},
"container_fs_io_time_weighted_seconds_total": {"device", "id", "image", "kubernetes_container_name", "kubernetes_namespace", "kubernetes_pod_name", "name"},
"container_fs_limit_bytes": {"device", "id", "image", "kubernetes_container_name", "kubernetes_namespace", "kubernetes_pod_name", "name"},
"container_fs_read_seconds_total": {"device", "id", "image", "kubernetes_container_name", "kubernetes_namespace", "kubernetes_pod_name", "name"},
"container_fs_reads_merged_total": {"device", "id", "image", "kubernetes_container_name", "kubernetes_namespace", "kubernetes_pod_name", "name"},
"container_fs_reads_total": {"device", "id", "image", "kubernetes_container_name", "kubernetes_namespace", "kubernetes_pod_name", "name"},
"container_fs_sector_reads_total": {"device", "id", "image", "kubernetes_container_name", "kubernetes_namespace", "kubernetes_pod_name", "name"},
"container_fs_sector_writes_total": {"device", "id", "image", "kubernetes_container_name", "kubernetes_namespace", "kubernetes_pod_name", "name"},
"container_fs_usage_bytes": {"device", "id", "image", "kubernetes_container_name", "kubernetes_namespace", "kubernetes_pod_name", "name"},
"container_fs_write_seconds_total": {"device", "id", "image", "kubernetes_container_name", "kubernetes_namespace", "kubernetes_pod_name", "name"},
"container_fs_writes_merged_total": {"device", "id", "image", "kubernetes_container_name", "kubernetes_namespace", "kubernetes_pod_name", "name"},
"container_fs_writes_total": {"device", "id", "image", "kubernetes_container_name", "kubernetes_namespace", "kubernetes_pod_name", "name"},
"container_last_seen": {"id", "image", "kubernetes_container_name", "kubernetes_namespace", "kubernetes_pod_name", "name"},
"container_memory_cache": {},
"container_memory_rss": {},
"container_memory_failcnt": {"id", "image", "kubernetes_container_name", "kubernetes_namespace", "kubernetes_pod_name", "name"},
"container_memory_failures_total": {"id", "image", "kubernetes_container_name", "kubernetes_namespace", "kubernetes_pod_name", "name", "scope", "type"},
"container_memory_usage_bytes": {"id", "image", "kubernetes_container_name", "kubernetes_namespace", "kubernetes_pod_name", "name"},
"container_memory_working_set_bytes": {"id", "image", "kubernetes_container_name", "kubernetes_namespace", "kubernetes_pod_name", "name"},
"container_network_receive_bytes_total": {"id", "interface", "image", "kubernetes_container_name", "kubernetes_namespace", "kubernetes_pod_name", "name"},
"container_network_receive_errors_total": {"id", "image", "interface", "kubernetes_container_name", "kubernetes_namespace", "kubernetes_pod_name", "name"},
"container_network_receive_packets_dropped_total": {"id", "image", "interface", "kubernetes_container_name", "kubernetes_namespace", "kubernetes_pod_name", "name"},
"container_network_receive_packets_total": {"id", "image", "interface", "kubernetes_container_name", "kubernetes_namespace", "kubernetes_pod_name", "name"},
"container_network_transmit_bytes_total": {"id", "interface", "image", "kubernetes_container_name", "kubernetes_namespace", "kubernetes_pod_name", "name"},
"container_network_transmit_errors_total": {"id", "interface", "image", "kubernetes_container_name", "kubernetes_namespace", "kubernetes_pod_name", "name"},
"container_network_transmit_packets_dropped_total": {"id", "interface", "image", "kubernetes_container_name", "kubernetes_namespace", "kubernetes_pod_name", "name"},
"container_network_transmit_packets_total": {"id", "interface", "image", "kubernetes_container_name", "kubernetes_namespace", "kubernetes_pod_name", "name"},
"container_scrape_error": {},
"container_spec_cpu_period": {"id", "image", "kubernetes_container_name", "kubernetes_namespace", "kubernetes_pod_name", "name"},
"container_spec_cpu_shares": {"id", "image", "kubernetes_container_name", "kubernetes_namespace", "kubernetes_pod_name", "name"},
"container_spec_memory_limit_bytes": {"id", "image", "kubernetes_container_name", "kubernetes_namespace", "kubernetes_pod_name", "name"},
"container_spec_memory_swap_limit_bytes": {"id", "image", "kubernetes_container_name", "kubernetes_namespace", "kubernetes_pod_name", "name"},
"container_start_time_seconds": {"id", "image", "kubernetes_container_name", "kubernetes_namespace", "kubernetes_pod_name", "name"},
"container_tasks_state": {"id", "image", "kubernetes_container_name", "kubernetes_namespace", "kubernetes_pod_name", "name", "state"},
"kubelet_container_manager_latency_microseconds": {"operation_type", "quantile"},
"kubelet_container_manager_latency_microseconds_count": {"operation_type"},
"kubelet_container_manager_latency_microseconds_sum": {"operation_type"},
"kubelet_containers_per_pod_count": {"quantile"},
"kubelet_containers_per_pod_count_count": {},
"kubelet_containers_per_pod_count_sum": {},
"kubelet_docker_operations": {"operation_type"},
"kubelet_docker_operations_errors": {"operation_type"},
"kubelet_docker_operations_timeout": {"operation_type"},
"kubelet_docker_operations_latency_microseconds": {"operation_type", "quantile"},
"kubelet_docker_operations_latency_microseconds_count": {"operation_type"},
"kubelet_docker_operations_latency_microseconds_sum": {"operation_type"},
"kubelet_generate_pod_status_latency_microseconds": {"quantile"},
"kubelet_generate_pod_status_latency_microseconds_count": {},
"kubelet_generate_pod_status_latency_microseconds_sum": {},
"kubelet_pleg_relist_latency_microseconds": {"quantile"},
"kubelet_pleg_relist_latency_microseconds_sum": {},
"kubelet_pleg_relist_latency_microseconds_count": {},
"kubelet_pleg_relist_interval_microseconds": {"quantile"},
"kubelet_pleg_relist_interval_microseconds_sum": {},
"kubelet_pleg_relist_interval_microseconds_count": {},
"kubelet_pod_start_latency_microseconds": {"quantile"},
"kubelet_pod_start_latency_microseconds_count": {},
"kubelet_pod_start_latency_microseconds_sum": {},
"kubelet_pod_worker_latency_microseconds": {"operation_type", "quantile"},
"kubelet_pod_worker_latency_microseconds_count": {"operation_type"},
"kubelet_pod_worker_latency_microseconds_sum": {"operation_type"},
"kubelet_pod_worker_start_latency_microseconds": {"quantile"},
"kubelet_pod_worker_start_latency_microseconds_count": {},
"kubelet_pod_worker_start_latency_microseconds_sum": {},
"kubelet_running_container_count": {},
"kubelet_running_pod_count": {},
"kubelet_sync_pods_latency_microseconds": {"quantile"},
"kubelet_sync_pods_latency_microseconds_count": {},
"kubelet_sync_pods_latency_microseconds_sum": {},
"machine_cpu_cores": {},
"machine_memory_bytes": {},
"rest_client_request_latency_microseconds": {"quantile", "url", "verb"},
"rest_client_request_latency_microseconds_count": {"url", "verb"},
"rest_client_request_latency_microseconds_sum": {"url", "verb"},
"rest_client_request_status_codes": {"code", "host", "method"},
}
var KubeletMetricsLabelsToSkip = sets.NewString(
"kubernetes_namespace",
"image",
"name",
)
type KubeletMetrics Metrics
@ -124,9 +31,6 @@ func (m *KubeletMetrics) Equal(o KubeletMetrics) bool {
func NewKubeletMetrics() KubeletMetrics {
result := NewMetrics()
for metric := range NecessaryKubeletMetrics {
result[metric] = make(model.Samples, 0)
}
return KubeletMetrics(result)
}
@ -148,7 +52,7 @@ func GrabKubeletMetricsWithoutProxy(nodeName string) (KubeletMetrics, error) {
func parseKubeletMetrics(data string) (KubeletMetrics, error) {
result := NewKubeletMetrics()
if err := parseMetrics(data, NecessaryKubeletMetrics, (*Metrics)(&result), nil); err != nil {
if err := parseMetrics(data, (*Metrics)(&result)); err != nil {
return KubeletMetrics{}, err
}
return result, nil

21
pkg/metrics/metrics_grabber.go
View File

@ -24,7 +24,6 @@ import (
client "k8s.io/kubernetes/pkg/client/unversioned"
"k8s.io/kubernetes/pkg/fields"
"k8s.io/kubernetes/pkg/master/ports"
"k8s.io/kubernetes/pkg/util/sets"
"k8s.io/kubernetes/pkg/util/system"
"github.com/golang/glog"
@ -108,7 +107,7 @@ func (g *MetricsGrabber) grabFromKubeletInternal(nodeName string, kubeletPort in
return parseKubeletMetrics(output)
}
func (g *MetricsGrabber) GrabFromScheduler(unknownMetrics sets.String) (SchedulerMetrics, error) {
func (g *MetricsGrabber) GrabFromScheduler() (SchedulerMetrics, error) {
if !g.registeredMaster {
return SchedulerMetrics{}, fmt.Errorf("Master's Kubelet is not registered. Skipping Scheduler's metrics gathering.")
}
@ -116,10 +115,10 @@ func (g *MetricsGrabber) GrabFromScheduler(unknownMetrics sets.String) (Schedule
if err != nil {
return SchedulerMetrics{}, err
}
return parseSchedulerMetrics(output, unknownMetrics)
return parseSchedulerMetrics(output)
}
func (g *MetricsGrabber) GrabFromControllerManager(unknownMetrics sets.String) (ControllerManagerMetrics, error) {
func (g *MetricsGrabber) GrabFromControllerManager() (ControllerManagerMetrics, error) {
if !g.registeredMaster {
return ControllerManagerMetrics{}, fmt.Errorf("Master's Kubelet is not registered. Skipping ControllerManager's metrics gathering.")
}
@ -127,22 +126,22 @@ func (g *MetricsGrabber) GrabFromControllerManager(unknownMetrics sets.String) (
if err != nil {
return ControllerManagerMetrics{}, err
}
return parseControllerManagerMetrics(output, unknownMetrics)
return parseControllerManagerMetrics(output)
}
func (g *MetricsGrabber) GrabFromApiServer(unknownMetrics sets.String) (ApiServerMetrics, error) {
func (g *MetricsGrabber) GrabFromApiServer() (ApiServerMetrics, error) {
output, err := g.getMetricsFromApiServer()
if err != nil {
return ApiServerMetrics{}, nil
}
return parseApiServerMetrics(output, unknownMetrics)
return parseApiServerMetrics(output)
}
func (g *MetricsGrabber) Grab(unknownMetrics sets.String) (MetricsCollection, error) {
func (g *MetricsGrabber) Grab() (MetricsCollection, error) {
result := MetricsCollection{}
var errs []error
if g.grabFromApiServer {
metrics, err := g.GrabFromApiServer(nil)
metrics, err := g.GrabFromApiServer()
if err != nil {
errs = append(errs, err)
} else {
@ -150,7 +149,7 @@ func (g *MetricsGrabber) Grab(unknownMetrics sets.String) (MetricsCollection, er
}
}
if g.grabFromScheduler {
metrics, err := g.GrabFromScheduler(nil)
metrics, err := g.GrabFromScheduler()
if err != nil {
errs = append(errs, err)
} else {
@ -158,7 +157,7 @@ func (g *MetricsGrabber) Grab(unknownMetrics sets.String) (MetricsCollection, er
}
}
if g.grabFromControllerManager {
metrics, err := g.GrabFromControllerManager(nil)
metrics, err := g.GrabFromControllerManager()
if err != nil {
errs = append(errs, err)
} else {

29
pkg/metrics/scheduler_metrics.go
View File

@ -16,28 +16,6 @@ limitations under the License.
package metrics
import (
"k8s.io/kubernetes/pkg/util/sets"
"github.com/prometheus/common/model"
)
var KnownSchedulerMetrics = map[string][]string{
"rest_client_request_latency_microseconds": {"url", "verb", "quantile"},
"rest_client_request_latency_microseconds_count": {"url", "verb"},
"rest_client_request_latency_microseconds_sum": {"url", "verb"},
"rest_client_request_status_codes": {"code", "host", "method"},
"scheduler_binding_latency_microseconds_bucket": {"le"},
"scheduler_binding_latency_microseconds_count": {},
"scheduler_binding_latency_microseconds_sum": {},
"scheduler_e2e_scheduling_latency_microseconds_bucket": {"le"},
"scheduler_e2e_scheduling_latency_microseconds_count": {},
"scheduler_e2e_scheduling_latency_microseconds_sum": {},
"scheduler_scheduling_algorithm_latency_microseconds_bucket": {"le"},
"scheduler_scheduling_algorithm_latency_microseconds_count": {},
"scheduler_scheduling_algorithm_latency_microseconds_sum": {},
}
type SchedulerMetrics Metrics
func (m *SchedulerMetrics) Equal(o SchedulerMetrics) bool {
@ -46,15 +24,12 @@ func (m *SchedulerMetrics) Equal(o SchedulerMetrics) bool {
func NewSchedulerMetrics() SchedulerMetrics {
result := NewMetrics()
for metric := range KnownSchedulerMetrics {
result[metric] = make(model.Samples, 0)
}
return SchedulerMetrics(result)
}
func parseSchedulerMetrics(data string, unknownMetrics sets.String) (SchedulerMetrics, error) {
func parseSchedulerMetrics(data string) (SchedulerMetrics, error) {
result := NewSchedulerMetrics()
if err := parseMetrics(data, KnownSchedulerMetrics, (*Metrics)(&result), unknownMetrics); err != nil {
if err := parseMetrics(data, (*Metrics)(&result)); err != nil {
return SchedulerMetrics{}, err
}
return result, nil

2
test/e2e/framework/framework.go
View File

@ -271,7 +271,7 @@ func (f *Framework) AfterEach() {
if err != nil {
Logf("Failed to create MetricsGrabber. Skipping metrics gathering.")
} else {
received, err := grabber.Grab(nil)
received, err := grabber.Grab()
if err != nil {
Logf("MetricsGrabber failed grab metrics. Skipping metrics gathering.")
} else {

73
test/e2e/metrics_grabber_test.go
View File

@ -22,62 +22,12 @@ import (
"k8s.io/kubernetes/pkg/api"
client "k8s.io/kubernetes/pkg/client/unversioned"
"k8s.io/kubernetes/pkg/metrics"
"k8s.io/kubernetes/pkg/util/sets"
"k8s.io/kubernetes/test/e2e/framework"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
)
// Missing = Assumed minus Observed, Invalid = Observed minus Assumed
func validateLabelSet(labelSet map[string][]string, data metrics.Metrics, invalidLabels map[string]sets.String, missingLabels map[string]sets.String) {
for metric, labels := range labelSet {
vector, found := data[metric]
Expect(found).To(Equal(true))
if found && len(vector) > 0 {
for _, observation := range vector {
for label := range observation.Metric {
// We need to check if it's a known label for this metric.
// Omit Prometheus internal metrics.
if strings.HasPrefix(string(label), "__") {
continue
}
invalidLabel := true
for _, knownLabel := range labels {
if string(label) == knownLabel {
invalidLabel = false
}
}
if invalidLabel && invalidLabels != nil {
if _, ok := invalidLabels[metric]; !ok {
invalidLabels[metric] = sets.NewString()
}
invalidLabels[metric].Insert(string(label))
}
}
}
}
}
}
func checkNecessaryMetrics(response metrics.Metrics, necessaryMetrics map[string][]string) {
missingLabels := make(map[string]sets.String)
validateLabelSet(metrics.CommonMetrics, response, nil, missingLabels)
validateLabelSet(necessaryMetrics, response, nil, missingLabels)
Expect(missingLabels).To(BeEmpty())
}
func checkMetrics(response metrics.Metrics, assumedMetrics map[string][]string) {
invalidLabels := make(map[string]sets.String)
missingLabels := make(map[string]sets.String)
validateLabelSet(metrics.CommonMetrics, response, invalidLabels, missingLabels)
validateLabelSet(assumedMetrics, response, invalidLabels, missingLabels)
Expect(missingLabels).To(BeEmpty())
Expect(invalidLabels).To(BeEmpty())
}
var _ = framework.KubeDescribe("MetricsGrabber", func() {
f := framework.NewDefaultFramework("metrics-grabber")
var c *client.Client
@ -92,12 +42,9 @@ var _ = framework.KubeDescribe("MetricsGrabber", func() {
It("should grab all metrics from API server.", func() {
By("Connecting to /metrics endpoint")
unknownMetrics := sets.NewString()
response, err := grabber.GrabFromApiServer(unknownMetrics)
response, err := grabber.GrabFromApiServer()
framework.ExpectNoError(err)
Expect(unknownMetrics).To(BeEmpty())
checkMetrics(metrics.Metrics(response), metrics.KnownApiServerMetrics)
Expect(response).NotTo(BeEmpty())
})
It("should grab all metrics from a Kubelet.", func() {
@ -106,7 +53,7 @@ var _ = framework.KubeDescribe("MetricsGrabber", func() {
Expect(nodes.Items).NotTo(BeEmpty())
response, err := grabber.GrabFromKubelet(nodes.Items[0].Name)
framework.ExpectNoError(err)
checkNecessaryMetrics(metrics.Metrics(response), metrics.NecessaryKubeletMetrics)
Expect(response).NotTo(BeEmpty())
})
It("should grab all metrics from a Scheduler.", func() {
@ -125,12 +72,9 @@ var _ = framework.KubeDescribe("MetricsGrabber", func() {
framework.Logf("Master is node registered. Skipping testing Scheduler metrics.")
return
}
unknownMetrics := sets.NewString()
response, err := grabber.GrabFromScheduler(unknownMetrics)
response, err := grabber.GrabFromScheduler()
framework.ExpectNoError(err)
Expect(unknownMetrics).To(BeEmpty())
checkMetrics(metrics.Metrics(response), metrics.KnownSchedulerMetrics)
Expect(response).NotTo(BeEmpty())
})
It("should grab all metrics from a ControllerManager.", func() {
@ -149,11 +93,8 @@ var _ = framework.KubeDescribe("MetricsGrabber", func() {
framework.Logf("Master is node registered. Skipping testing ControllerManager metrics.")
return
}
unknownMetrics := sets.NewString()
response, err := grabber.GrabFromControllerManager(unknownMetrics)
response, err := grabber.GrabFromControllerManager()
framework.ExpectNoError(err)
Expect(unknownMetrics).To(BeEmpty())
checkMetrics(metrics.Metrics(response), metrics.KnownControllerManagerMetrics)
Expect(response).NotTo(BeEmpty())
})
})