diff --git a/CHANGELOG.next.asciidoc b/CHANGELOG.next.asciidoc index 73b8192734fa..90ff153f2c9e 100644 --- a/CHANGELOG.next.asciidoc +++ b/CHANGELOG.next.asciidoc @@ -533,6 +533,7 @@ https://github.com/elastic/beats/compare/v7.0.0-alpha2...master[Check the HEAD d - Add module for ActiveMQ. {pull}14788[14788] - 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 a2c436ea6ea9..9ca5adc6f070 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 f2ab94d5731d..9df1068f4423 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 50c64c9994af..adeb94736f79 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"]