From 85359a34c60c5370c6d6700e05dc0109023e468d Mon Sep 17 00:00:00 2001 From: Ioannis Androulidakis Date: Tue, 16 Feb 2021 14:29:40 +0200 Subject: [PATCH] [Metricbeat][Kubernetes] Extend state_node with more conditions (#23905) (cherry picked from commit 125c29d28e1cf718aac4d8589406097707819458) --- CHANGELOG.next.asciidoc | 1 + metricbeat/docs/fields.asciidoc | 40 +++++++++++++++++++ metricbeat/helper/prometheus/metric.go | 29 ++++++++------ .../helper/prometheus/prometheus_test.go | 33 +++++++++++++-- metricbeat/module/kubernetes/fields.go | 2 +- .../kubernetes/state_node/_meta/fields.yml | 16 ++++++++ .../state_node/_meta/test/ksm.v1.3.0.expected | 3 ++ .../state_node/_meta/test/ksm.v1.8.0.expected | 3 ++ .../kubernetes/state_node/state_node.go | 14 ++++--- 9 files changed, 120 insertions(+), 21 deletions(-) diff --git a/CHANGELOG.next.asciidoc b/CHANGELOG.next.asciidoc index 68ababee5e2..2935cb15a65 100644 --- a/CHANGELOG.next.asciidoc +++ b/CHANGELOG.next.asciidoc @@ -67,6 +67,7 @@ https://github.com/elastic/beats/compare/v7.0.0-alpha2...master[Check the HEAD d - Use ingress/egress instead of inbound/outbound for system/socket metricset. {pull}22992[22992] - Change types of numeric metrics from Kubelet summary api to double so as to cover big numbers. {pull}23335[23335] - Add container.image.name and containe.name ECS fields for state_container. {pull}23802[23802] +- Add support for the MemoryPressure, DiskPressure, OutOfDisk and PIDPressure status conditions in state_node. {pull}[23905] *Packetbeat* diff --git a/metricbeat/docs/fields.asciidoc b/metricbeat/docs/fields.asciidoc index 94ded20820f..f14aea75cda 100644 --- a/metricbeat/docs/fields.asciidoc +++ b/metricbeat/docs/fields.asciidoc @@ -29833,6 +29833,46 @@ type: keyword Node unschedulable status +type: boolean + +-- + +*`kubernetes.node.status.memory_pressure`*:: ++ +-- +Node MemoryPressure status + + +type: boolean + +-- + +*`kubernetes.node.status.disk_pressure`*:: ++ +-- +Node DiskPressure status + + +type: boolean + +-- + +*`kubernetes.node.status.out_of_disk`*:: ++ +-- +Node OutOfDisk status + + +type: boolean + +-- + +*`kubernetes.node.status.pid_pressure`*:: ++ +-- +Node PIDPressure status + + type: boolean -- diff --git a/metricbeat/helper/prometheus/metric.go b/metricbeat/helper/prometheus/metric.go index a040ed65dae..5f3f1199f31 100644 --- a/metricbeat/helper/prometheus/metric.go +++ b/metricbeat/helper/prometheus/metric.go @@ -79,10 +79,11 @@ type MetricOption interface { Process(field string, value interface{}, labels common.MapStr) (string, interface{}, common.MapStr) } -// OpFilter only processes metrics matching the given filter -func OpFilter(filter map[string]string) MetricOption { - return opFilter{ - labels: filter, +// OpFilterMap only processes metrics matching the given filter +func OpFilterMap(label string, filterMap map[string]string) MetricOption { + return opFilterMap{ + label: label, + filterMap: filterMap, } } @@ -331,18 +332,22 @@ func (m *infoMetric) GetField() string { return "" } -type opFilter struct { - labels map[string]string +type opFilterMap struct { + label string + filterMap map[string]string } -// Process will return nil if labels don't match the filter -func (o opFilter) Process(field string, value interface{}, labels common.MapStr) (string, interface{}, common.MapStr) { - for k, v := range o.labels { - if labels[k] != v { - return "", nil, nil +// Called by the Prometheus helper to apply extra options on retrieved metrics +// Check whether the value of the specified label is allowed and, if yes, return the metric via the specified mapped field +// Else, if the specified label does not match the filter, return nil +// This is useful in cases where multiple Metricbeat fields need to be defined per Prometheus metric, based on label values +func (o opFilterMap) Process(field string, value interface{}, labels common.MapStr) (string, interface{}, common.MapStr) { + for k, v := range o.filterMap { + if labels[o.label] == k { + return fmt.Sprintf("%v.%v", field, v), value, labels } } - return field, value, labels + return "", nil, nil } type opLowercaseValue struct{} diff --git a/metricbeat/helper/prometheus/prometheus_test.go b/metricbeat/helper/prometheus/prometheus_test.go index 974f51f1a10..f044c2f422f 100644 --- a/metricbeat/helper/prometheus/prometheus_test.go +++ b/metricbeat/helper/prometheus/prometheus_test.go @@ -397,9 +397,36 @@ func TestPrometheus(t *testing.T) { msg: "Label metrics, filter", mapping: &MetricsMapping{ Metrics: map[string]MetricMap{ - "first_metric": LabelMetric("first.metric", "label4", OpLowercaseValue(), OpFilter(map[string]string{ - "foo": "filtered", - })), + "first_metric": LabelMetric("first.metric", "label4", OpFilterMap( + "label1", + map[string]string{"value1": "foo"}, + )), + }, + Labels: map[string]LabelMap{ + "label1": Label("labels.label1"), + }, + }, + expected: []common.MapStr{ + common.MapStr{ + "first": common.MapStr{ + "metric": common.MapStr{ + "foo": "FOO", + }, + }, + "labels": common.MapStr{ + "label1": "value1", + }, + }, + }, + }, + { + msg: "Label metrics, filter", + mapping: &MetricsMapping{ + Metrics: map[string]MetricMap{ + "first_metric": LabelMetric("first.metric", "label4", OpLowercaseValue(), OpFilterMap( + "foo", + map[string]string{"Filtered": "filtered"}, + )), }, Labels: map[string]LabelMap{ "label1": Label("labels.label1"), diff --git a/metricbeat/module/kubernetes/fields.go b/metricbeat/module/kubernetes/fields.go index b634b273cd2..3cbe65ed2bd 100644 --- a/metricbeat/module/kubernetes/fields.go +++ b/metricbeat/module/kubernetes/fields.go @@ -32,5 +32,5 @@ func init() { // AssetKubernetes returns asset data. // This is the base64 encoded gzipped contents of module/kubernetes. func AssetKubernetes() string { - return "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" + return "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" } diff --git a/metricbeat/module/kubernetes/state_node/_meta/fields.yml b/metricbeat/module/kubernetes/state_node/_meta/fields.yml index ea0f952089e..b7d5f2a1920 100644 --- a/metricbeat/module/kubernetes/state_node/_meta/fields.yml +++ b/metricbeat/module/kubernetes/state_node/_meta/fields.yml @@ -15,6 +15,22 @@ type: boolean description: > Node unschedulable status + - name: memory_pressure + type: boolean + description: > + Node MemoryPressure status + - name: disk_pressure + type: boolean + description: > + Node DiskPressure status + - name: out_of_disk + type: boolean + description: > + Node OutOfDisk status + - name: pid_pressure + type: boolean + description: > + Node PIDPressure status - name: cpu type: group fields: diff --git a/metricbeat/module/kubernetes/state_node/_meta/test/ksm.v1.3.0.expected b/metricbeat/module/kubernetes/state_node/_meta/test/ksm.v1.3.0.expected index c560b169d77..38a0cc0dae1 100644 --- a/metricbeat/module/kubernetes/state_node/_meta/test/ksm.v1.3.0.expected +++ b/metricbeat/module/kubernetes/state_node/_meta/test/ksm.v1.3.0.expected @@ -29,6 +29,9 @@ } }, "status": { + "disk_pressure": "false", + "memory_pressure": "false", + "out_of_disk": "false", "ready": "true", "unschedulable": false } diff --git a/metricbeat/module/kubernetes/state_node/_meta/test/ksm.v1.8.0.expected b/metricbeat/module/kubernetes/state_node/_meta/test/ksm.v1.8.0.expected index 7b0390a04a2..371c9ca294b 100644 --- a/metricbeat/module/kubernetes/state_node/_meta/test/ksm.v1.8.0.expected +++ b/metricbeat/module/kubernetes/state_node/_meta/test/ksm.v1.8.0.expected @@ -29,6 +29,9 @@ } }, "status": { + "disk_pressure": "false", + "memory_pressure": "false", + "pid_pressure": "false", "ready": "true", "unschedulable": false } diff --git a/metricbeat/module/kubernetes/state_node/state_node.go b/metricbeat/module/kubernetes/state_node/state_node.go index bd334915240..f2a1a6b965e 100644 --- a/metricbeat/module/kubernetes/state_node/state_node.go +++ b/metricbeat/module/kubernetes/state_node/state_node.go @@ -49,12 +49,16 @@ var ( "kube_node_status_allocatable_cpu_cores": p.Metric("cpu.allocatable.cores"), "kube_node_spec_unschedulable": p.BooleanMetric("status.unschedulable"), "kube_node_status_ready": p.LabelMetric("status.ready", "condition"), - "kube_node_status_condition": p.LabelMetric("status.ready", "status", - p.OpFilter(map[string]string{ - "condition": "Ready", - })), + "kube_node_status_condition": p.LabelMetric("status", "status", p.OpFilterMap( + "condition", map[string]string{ + "Ready": "ready", + "MemoryPressure": "memory_pressure", + "DiskPressure": "disk_pressure", + "OutOfDisk": "out_of_disk", + "PIDPressure": "pid_pressure", + }, + )), }, - Labels: map[string]p.LabelMap{ "node": p.KeyLabel("name"), },