diff --git a/CHANGELOG.next.asciidoc b/CHANGELOG.next.asciidoc index dbee2be60b60..6a9bb35edd16 100644 --- a/CHANGELOG.next.asciidoc +++ b/CHANGELOG.next.asciidoc @@ -552,6 +552,7 @@ https://github.com/elastic/beats/compare/v7.0.0-alpha2...master[Check the HEAD d - Enable script processor. {pull}14711[14711] - Enable wildcard for cloudwatch metricset namespace. {pull}14971[14971] {issue}14965[14965] - Add `kube-state-metrics` `state_service` metrics for kubernetes module. {pull}14794[14794] +- Add `kube-state-metrics` `state_persistentvolume` metrics for kubernetes module. {pull}14859[14859] - Add `kube-state-metrics` `state_persistentvolumeclaim` metrics for kubernetes module. {pull}15066[15066] - Add usage metricset in aws modules. {pull}14925[14925] {issue}14935[14935] - Add billing metricset in aws modules. {pull}14801[14801] {issue}14934[14934] diff --git a/metricbeat/docs/fields.asciidoc b/metricbeat/docs/fields.asciidoc index 8db776bcaa4e..6430cef22294 100644 --- a/metricbeat/docs/fields.asciidoc +++ b/metricbeat/docs/fields.asciidoc @@ -19296,6 +19296,49 @@ type: long -- +[float] +=== persistentvolume + +kubernetes persistent volume metrics from kube-state-metrics + + + +*`kubernetes.persistentvolume.name`*:: ++ +-- +Volume name. + +type: keyword + +-- + +*`kubernetes.persistentvolume.capacity.bytes`*:: ++ +-- +Volume capacity + +type: long + +-- + +*`kubernetes.persistentvolume.phase`*:: ++ +-- +Volume phase according to kubernetes + +type: keyword + +-- + +*`kubernetes.persistentvolume.storage_class`*:: ++ +-- +Storage class for the volume + +type: keyword + +-- + [float] === persistentvolumeclaim diff --git a/metricbeat/docs/modules/kubernetes.asciidoc b/metricbeat/docs/modules/kubernetes.asciidoc index 9f80e38dce2c..0297fdd440d2 100644 --- a/metricbeat/docs/modules/kubernetes.asciidoc +++ b/metricbeat/docs/modules/kubernetes.asciidoc @@ -96,6 +96,7 @@ metricbeat.modules: - state_cronjob - state_resourcequota - state_service + - state_persistentvolume - state_persistentvolumeclaim period: 10s hosts: ["kube-state-metrics:8080"] diff --git a/metricbeat/helper/prometheus/prometheus.go b/metricbeat/helper/prometheus/prometheus.go index 82145366f306..69c959e0b3a9 100644 --- a/metricbeat/helper/prometheus/prometheus.go +++ b/metricbeat/helper/prometheus/prometheus.go @@ -205,7 +205,6 @@ func (p *prometheus) GetProcessedMetrics(mapping *MetricsMapping) ([]common.MapS event[k] = v } events = append(events, event) - } // fill info from infoMetrics @@ -228,7 +227,6 @@ func (p *prometheus) GetProcessedMetrics(mapping *MetricsMapping) ([]common.MapS } return events, nil - } // infoMetricData keeps data about an infoMetric diff --git a/metricbeat/include/list_docker.go b/metricbeat/include/list_docker.go index ec22f01465d5..b1cc337aa80b 100644 --- a/metricbeat/include/list_docker.go +++ b/metricbeat/include/list_docker.go @@ -44,6 +44,7 @@ import ( _ "github.com/elastic/beats/metricbeat/module/kubernetes/state_cronjob" _ "github.com/elastic/beats/metricbeat/module/kubernetes/state_deployment" _ "github.com/elastic/beats/metricbeat/module/kubernetes/state_node" + _ "github.com/elastic/beats/metricbeat/module/kubernetes/state_persistentvolume" _ "github.com/elastic/beats/metricbeat/module/kubernetes/state_persistentvolumeclaim" _ "github.com/elastic/beats/metricbeat/module/kubernetes/state_pod" _ "github.com/elastic/beats/metricbeat/module/kubernetes/state_replicaset" diff --git a/metricbeat/metricbeat.reference.yml b/metricbeat/metricbeat.reference.yml index 8bb17d5b4b1f..0ced4f40cd61 100644 --- a/metricbeat/metricbeat.reference.yml +++ b/metricbeat/metricbeat.reference.yml @@ -475,6 +475,7 @@ metricbeat.modules: - state_cronjob - state_resourcequota - state_service + - state_persistentvolume - state_persistentvolumeclaim period: 10s hosts: ["kube-state-metrics:8080"] diff --git a/metricbeat/module/kubernetes/_meta/config.reference.yml b/metricbeat/module/kubernetes/_meta/config.reference.yml index f81071b439b2..1a418db81f48 100644 --- a/metricbeat/module/kubernetes/_meta/config.reference.yml +++ b/metricbeat/module/kubernetes/_meta/config.reference.yml @@ -36,6 +36,7 @@ - state_cronjob - state_resourcequota - state_service + - state_persistentvolume - state_persistentvolumeclaim period: 10s hosts: ["kube-state-metrics:8080"] diff --git a/metricbeat/module/kubernetes/_meta/config.yml b/metricbeat/module/kubernetes/_meta/config.yml index 15fd61b0e5f9..f242454913bd 100644 --- a/metricbeat/module/kubernetes/_meta/config.yml +++ b/metricbeat/module/kubernetes/_meta/config.yml @@ -36,6 +36,7 @@ # - state_cronjob # - state_resourcequota # - state_service +# - state_persistentvolume # - state_persistentvolumeclaim # period: 10s # hosts: ["kube-state-metrics:8080"] diff --git a/metricbeat/module/kubernetes/fields.go b/metricbeat/module/kubernetes/fields.go index 6a67e5f29c92..6feb3a433208 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 ../metricbeat/module/kubernetes. func AssetKubernetes() string { - return "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" + return "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" } diff --git a/metricbeat/module/kubernetes/state_persistentvolume/README.md b/metricbeat/module/kubernetes/state_persistentvolume/README.md new file mode 100644 index 000000000000..33f7c8bfc4c3 --- /dev/null +++ b/metricbeat/module/kubernetes/state_persistentvolume/README.md @@ -0,0 +1,32 @@ +# Kube-state-metrics/PersistentVolume + + +This metricset connects to kube-state-metrics endpoint to retrieve and report Persistent Volume metrics. + +## Version history + +- November 2019, first release using kube-state-metrics `v1.8.0`. + +## Configuration + +See the metricset documentation for the configuration reference. + +## Manual testing + +Running a minikube cluster allows you to create persistent volume using the `/data/` directory at hostpath + +```yaml +apiVersion: v1 +kind: PersistentVolume +metadata: + name: pv0001 +spec: + accessModes: + - ReadWriteOnce + capacity: + storage: 5Gi + hostPath: + path: /data/pv0001/ +``` + +Try adding labels, and creating volumes from pods using PVC. \ No newline at end of file diff --git a/metricbeat/module/kubernetes/state_persistentvolume/_meta/fields.yml b/metricbeat/module/kubernetes/state_persistentvolume/_meta/fields.yml new file mode 100644 index 000000000000..bfc7e903cdcd --- /dev/null +++ b/metricbeat/module/kubernetes/state_persistentvolume/_meta/fields.yml @@ -0,0 +1,21 @@ +- name: persistentvolume + type: group + description: > + kubernetes persistent volume metrics from kube-state-metrics + release: experimental + fields: + - name: name + type: keyword + description: Volume name. + - name: capacity.bytes + type: long + description: Volume capacity + - name: phase + type: keyword + description: Volume phase according to kubernetes + - name: storage_class + type: keyword + description: Storage class for the volume + + + diff --git a/metricbeat/module/kubernetes/state_persistentvolume/_meta/test/ksm-unit-1.8 b/metricbeat/module/kubernetes/state_persistentvolume/_meta/test/ksm-unit-1.8 new file mode 100644 index 000000000000..9a133c3b3b0e --- /dev/null +++ b/metricbeat/module/kubernetes/state_persistentvolume/_meta/test/ksm-unit-1.8 @@ -0,0 +1,41 @@ +# HELP kube_persistentvolume_status_phase The phase indicates if a volume is available, bound to a claim, or released by a claim. +# TYPE kube_persistentvolume_status_phase gauge +kube_persistentvolume_status_phase{persistentvolume="test-pv-pending",phase="Available"} 0 +kube_persistentvolume_status_phase{persistentvolume="test-pv-pending",phase="Bound"} 0 +kube_persistentvolume_status_phase{persistentvolume="test-pv-pending",phase="Failed"} 0 +kube_persistentvolume_status_phase{persistentvolume="test-pv-pending",phase="Pending"} 1 +kube_persistentvolume_status_phase{persistentvolume="test-pv-pending",phase="Released"} 0 +kube_persistentvolume_status_phase{persistentvolume="test-pv-bound",phase="Available"} 0 +kube_persistentvolume_status_phase{persistentvolume="test-pv-bound",phase="Bound"} 1 +kube_persistentvolume_status_phase{persistentvolume="test-pv-bound",phase="Failed"} 0 +kube_persistentvolume_status_phase{persistentvolume="test-pv-bound",phase="Pending"} 0 +kube_persistentvolume_status_phase{persistentvolume="test-pv-bound",phase="Released"} 0 +kube_persistentvolume_status_phase{persistentvolume="test-pv-released",phase="Available"} 0 +kube_persistentvolume_status_phase{persistentvolume="test-pv-released",phase="Bound"} 0 +kube_persistentvolume_status_phase{persistentvolume="test-pv-released",phase="Failed"} 0 +kube_persistentvolume_status_phase{persistentvolume="test-pv-released",phase="Pending"} 0 +kube_persistentvolume_status_phase{persistentvolume="test-pv-released",phase="Released"} 1 +kube_persistentvolume_status_phase{persistentvolume="test-pv-failed",phase="Available"} 0 +kube_persistentvolume_status_phase{persistentvolume="test-pv-failed",phase="Bound"} 0 +kube_persistentvolume_status_phase{persistentvolume="test-pv-failed",phase="Failed"} 1 +kube_persistentvolume_status_phase{persistentvolume="test-pv-failed",phase="Pending"} 0 +kube_persistentvolume_status_phase{persistentvolume="test-pv-failed",phase="Released"} 0 +kube_persistentvolume_status_phase{persistentvolume="test-pv-available",phase="Available"} 1 +kube_persistentvolume_status_phase{persistentvolume="test-pv-available",phase="Bound"} 0 +kube_persistentvolume_status_phase{persistentvolume="test-pv-available",phase="Failed"} 0 +kube_persistentvolume_status_phase{persistentvolume="test-pv-available",phase="Pending"} 0 +kube_persistentvolume_status_phase{persistentvolume="test-pv-available",phase="Released"} 0 +# HELP kube_persistentvolume_info Information about persistentvolume. +# TYPE kube_persistentvolume_info gauge +kube_persistentvolume_info{persistentvolume="test-pv-available",storageclass=""} 1 +kube_persistentvolume_info{persistentvolume="test-labeled-pv",storageclass=""} 1 +kube_persistentvolume_info{persistentvolume="test-unlabeled-pv",storageclass="sc1"} 1 +# HELP kube_persistentvolume_labels Kubernetes labels converted to Prometheus labels. +# TYPE kube_persistentvolume_labels gauge +kube_persistentvolume_labels{label_app="mysql-server",persistentvolume="test-labeled-pv"} 1 +kube_persistentvolume_labels{persistentvolume="test-unlabeled-pv"} 1 +# HELP kube_persistentvolume_capacity_bytes Persistentvolume capacity in bytes. +# TYPE kube_persistentvolume_capacity_bytes gauge +kube_persistentvolume_capacity_bytes{persistentvolume="test-pv"} 5.36870912e+09 +kube_persistentvolume_capacity_bytes{persistentvolume="test-labeled-pv"} 5.36870912e+09 +kube_persistentvolume_capacity_bytes{persistentvolume="test-unlabeled-pv"} 5.36870912e+09 diff --git a/metricbeat/module/kubernetes/state_persistentvolume/_meta/test/ksm-unit-1.8.expected b/metricbeat/module/kubernetes/state_persistentvolume/_meta/test/ksm-unit-1.8.expected new file mode 100644 index 000000000000..1cf75352eb09 --- /dev/null +++ b/metricbeat/module/kubernetes/state_persistentvolume/_meta/test/ksm-unit-1.8.expected @@ -0,0 +1,157 @@ +[ + { + "RootFields": {}, + "ModuleFields": null, + "MetricSetFields": { + "name": "test-pv-bound", + "phase": "Bound" + }, + "Index": "", + "ID": "", + "Namespace": "kubernetes.persistentvolume", + "Timestamp": "0001-01-01T00:00:00Z", + "Error": null, + "Host": "", + "Service": "", + "Took": 0, + "Period": 0, + "DisableTimeSeries": false + }, + { + "RootFields": {}, + "ModuleFields": null, + "MetricSetFields": { + "capacity": { + "bytes": 5368709120 + }, + "name": "test-pv" + }, + "Index": "", + "ID": "", + "Namespace": "kubernetes.persistentvolume", + "Timestamp": "0001-01-01T00:00:00Z", + "Error": null, + "Host": "", + "Service": "", + "Took": 0, + "Period": 0, + "DisableTimeSeries": false + }, + { + "RootFields": {}, + "ModuleFields": null, + "MetricSetFields": { + "name": "test-pv-pending", + "phase": "Pending" + }, + "Index": "", + "ID": "", + "Namespace": "kubernetes.persistentvolume", + "Timestamp": "0001-01-01T00:00:00Z", + "Error": null, + "Host": "", + "Service": "", + "Took": 0, + "Period": 0, + "DisableTimeSeries": false + }, + { + "RootFields": {}, + "ModuleFields": null, + "MetricSetFields": { + "name": "test-pv-available", + "phase": "Available" + }, + "Index": "", + "ID": "", + "Namespace": "kubernetes.persistentvolume", + "Timestamp": "0001-01-01T00:00:00Z", + "Error": null, + "Host": "", + "Service": "", + "Took": 0, + "Period": 0, + "DisableTimeSeries": false + }, + { + "RootFields": {}, + "ModuleFields": null, + "MetricSetFields": { + "capacity": { + "bytes": 5368709120 + }, + "name": "test-unlabeled-pv", + "storage_class": "sc1" + }, + "Index": "", + "ID": "", + "Namespace": "kubernetes.persistentvolume", + "Timestamp": "0001-01-01T00:00:00Z", + "Error": null, + "Host": "", + "Service": "", + "Took": 0, + "Period": 0, + "DisableTimeSeries": false + }, + { + "RootFields": {}, + "ModuleFields": null, + "MetricSetFields": { + "name": "test-pv-released", + "phase": "Released" + }, + "Index": "", + "ID": "", + "Namespace": "kubernetes.persistentvolume", + "Timestamp": "0001-01-01T00:00:00Z", + "Error": null, + "Host": "", + "Service": "", + "Took": 0, + "Period": 0, + "DisableTimeSeries": false + }, + { + "RootFields": {}, + "ModuleFields": null, + "MetricSetFields": { + "name": "test-pv-failed", + "phase": "Failed" + }, + "Index": "", + "ID": "", + "Namespace": "kubernetes.persistentvolume", + "Timestamp": "0001-01-01T00:00:00Z", + "Error": null, + "Host": "", + "Service": "", + "Took": 0, + "Period": 0, + "DisableTimeSeries": false + }, + { + "RootFields": {}, + "ModuleFields": { + "labels": { + "app": "mysql-server" + } + }, + "MetricSetFields": { + "capacity": { + "bytes": 5368709120 + }, + "name": "test-labeled-pv" + }, + "Index": "", + "ID": "", + "Namespace": "kubernetes.persistentvolume", + "Timestamp": "0001-01-01T00:00:00Z", + "Error": null, + "Host": "", + "Service": "", + "Took": 0, + "Period": 0, + "DisableTimeSeries": false + } +] \ No newline at end of file diff --git a/metricbeat/module/kubernetes/state_persistentvolume/state_persistentvolume.go b/metricbeat/module/kubernetes/state_persistentvolume/state_persistentvolume.go new file mode 100644 index 000000000000..7c55729374de --- /dev/null +++ b/metricbeat/module/kubernetes/state_persistentvolume/state_persistentvolume.go @@ -0,0 +1,88 @@ +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you 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 state_persistentvolume + +import ( + p "github.com/elastic/beats/metricbeat/helper/prometheus" + "github.com/elastic/beats/metricbeat/mb" +) + +func init() { + mb.Registry.MustAddMetricSet("kubernetes", "state_persistentvolume", + NewPersistentVolumeMetricSet, + mb.WithHostParser(p.HostParser)) +} + +// PersistentVolumeMetricSet is a prometheus based MetricSet that looks for +// mb.ModuleDataKey prefixed fields and puts then at the module level +type PersistentVolumeMetricSet struct { + mb.BaseMetricSet + prometheus p.Prometheus + mapping *p.MetricsMapping +} + +// NewPersistentVolumeMetricSet returns a prometheus based metricset for Persistent Volumes +func NewPersistentVolumeMetricSet(base mb.BaseMetricSet) (mb.MetricSet, error) { + prometheus, err := p.NewPrometheusClient(base) + if err != nil { + return nil, err + } + + return &PersistentVolumeMetricSet{ + BaseMetricSet: base, + prometheus: prometheus, + mapping: &p.MetricsMapping{ + Metrics: map[string]p.MetricMap{ + "kube_persistentvolume_capacity_bytes": p.Metric("capacity.bytes"), + "kube_persistentvolume_status_phase": p.LabelMetric("phase", "phase"), + "kube_persistentvolume_labels": p.ExtendedInfoMetric( + p.Configuration{ + StoreNonMappedLabels: true, + NonMappedLabelsPlacement: mb.ModuleDataKey + ".labels", + MetricProcessingOptions: []p.MetricOption{p.OpLabelKeyPrefixRemover("label_")}, + }), + "kube_persistentvolume_info": p.InfoMetric(), + }, + Labels: map[string]p.LabelMap{ + "persistentvolume": p.KeyLabel("name"), + "storageclass": p.Label("storage_class"), + }, + }, + }, nil +} + +// Fetch prometheus metrics and treats those prefixed by mb.ModuleDataKey as +// module rooted fields at the event that gets reported +func (m *PersistentVolumeMetricSet) Fetch(reporter mb.ReporterV2) { + events, err := m.prometheus.GetProcessedMetrics(m.mapping) + if err != nil { + m.Logger().Error(err) + reporter.Error(err) + return + } + + for _, event := range events { + event[mb.NamespaceKey] = "persistentvolume" + reported := reporter.Event(mb.TransformMapStrToEvent("kubernetes", event, nil)) + if !reported { + m.Logger().Debug("error trying to emit event") + return + } + } + return +} diff --git a/metricbeat/module/kubernetes/state_persistentvolume/state_persistentvolume_test.go b/metricbeat/module/kubernetes/state_persistentvolume/state_persistentvolume_test.go new file mode 100644 index 000000000000..707b5e147962 --- /dev/null +++ b/metricbeat/module/kubernetes/state_persistentvolume/state_persistentvolume_test.go @@ -0,0 +1,39 @@ +// Licensed to Elasticsearch B.V. under one or more contributor +// license agreements. See the NOTICE file distributed with +// this work for additional information regarding copyright +// ownership. Elasticsearch B.V. licenses this file to you 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. + +// +build !integration + +package state_persistentvolume + +import ( + "testing" + + "github.com/elastic/beats/metricbeat/helper/prometheus/ptest" +) + +const testFile = "_meta/test/metrics" + +func TestEventMapping(t *testing.T) { + ptest.TestMetricSet(t, "kubernetes", "state_persistentvolume", + ptest.TestCases{ + { + MetricsFile: "./_meta/test/ksm-unit-1.8", + ExpectedFile: "./_meta/test/ksm-unit-1.8.expected", + }, + }, + ) +} diff --git a/metricbeat/module/kubernetes/state_persistentvolumeclaim/README.md b/metricbeat/module/kubernetes/state_persistentvolumeclaim/README.md index 383b584c7c06..6d7ac4518c22 100644 --- a/metricbeat/module/kubernetes/state_persistentvolumeclaim/README.md +++ b/metricbeat/module/kubernetes/state_persistentvolumeclaim/README.md @@ -12,4 +12,39 @@ See the metricset documentation for the configuration reference. ## Manual testing -// TODO +Create Persistent Volume Claims. +- Use non existent storage classes to stuck them pending +``` +apiVersion: v1 +kind: PersistentVolumeClaim +metadata: + name: claim2 +spec: + accessModes: + - ReadWriteOnce + resources: + requests: + storage: 8Gi + storageClassName: notexisting + volumeMode: Filesystem +``` + +- Add labels +``` +apiVersion: v1 +kind: PersistentVolumeClaim +metadata: + labels: + category: disposable + team: observability + name: claim1 +spec: + accessModes: + - ReadWriteOnce + resources: + requests: + storage: 80Gi + storageClassName: standard + volumeMode: Filesystem +``` + diff --git a/metricbeat/modules.d/kubernetes.yml.disabled b/metricbeat/modules.d/kubernetes.yml.disabled index 02e5e372d491..5f6fa9efce31 100644 --- a/metricbeat/modules.d/kubernetes.yml.disabled +++ b/metricbeat/modules.d/kubernetes.yml.disabled @@ -39,6 +39,7 @@ # - state_cronjob # - state_resourcequota # - state_service +# - state_persistentvolume # - state_persistentvolumeclaim # period: 10s # hosts: ["kube-state-metrics:8080"] diff --git a/x-pack/metricbeat/metricbeat.reference.yml b/x-pack/metricbeat/metricbeat.reference.yml index 83f4608398eb..cecd53f88e98 100644 --- a/x-pack/metricbeat/metricbeat.reference.yml +++ b/x-pack/metricbeat/metricbeat.reference.yml @@ -616,6 +616,7 @@ metricbeat.modules: - state_cronjob - state_resourcequota - state_service + - state_persistentvolume - state_persistentvolumeclaim period: 10s hosts: ["kube-state-metrics:8080"]