Add Btrfs collector (#1512)

* Add procfs/btrfs to vendor folder
* Add Btrfs collector

Resolves #1100

Signed-off-by: Silke Hofstra <silke@slxh.eu>

1 files changed, 189 insertions, 0 deletions

diff --git a/collector/btrfs_linux.go b/collector/btrfs_linux.go
new file mode 100644
index 0000000..2336e65
--- /dev/null
+++ b/collector/btrfs_linux.go
@@ -0,0 +1,189 @@
+// Copyright 2019 The Prometheus 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.
+
+// +build !nobtrfs
+
+package collector
+
+import (
+        "fmt"
+
+        "github.com/go-kit/kit/log"
+        "github.com/prometheus/client_golang/prometheus"
+        "github.com/prometheus/procfs/btrfs"
+)
+
+// A btrfsCollector is a Collector which gathers metrics from Btrfs filesystems.
+type btrfsCollector struct {
+        fs     btrfs.FS
+        logger log.Logger
+}
+
+func init() {
+        registerCollector("btrfs", defaultEnabled, NewBtrfsCollector)
+}
+
+// NewBtrfsCollector returns a new Collector exposing Btrfs statistics.
+func NewBtrfsCollector(logger log.Logger) (Collector, error) {
+        fs, err := btrfs.NewFS(*sysPath)
+        if err != nil {
+                return nil, fmt.Errorf("failed to open sysfs: %v", err)
+        }
+
+        return &btrfsCollector{
+                fs:     fs,
+                logger: logger,
+        }, nil
+}
+
+// Update retrieves and exports Btrfs statistics.
+// It implements Collector.
+func (c *btrfsCollector) Update(ch chan<- prometheus.Metric) error {
+        stats, err := c.fs.Stats()
+        if err != nil {
+                return fmt.Errorf("failed to retrieve Btrfs stats: %v", err)
+        }
+
+        for _, s := range stats {
+                c.updateBtrfsStats(ch, s)
+        }
+
+        return nil
+}
+
+// btrfsMetric represents a single Btrfs metric that is converted into a Prometheus Metric.
+type btrfsMetric struct {
+        name            string
+        desc            string
+        value           float64
+        extraLabel      []string
+        extraLabelValue []string
+}
+
+// updateBtrfsStats collects statistics for one bcache ID.
+func (c *btrfsCollector) updateBtrfsStats(ch chan<- prometheus.Metric, s *btrfs.Stats) {
+        const subsystem = "btrfs"
+
+        // Basic information about the filesystem.
+        devLabels := []string{"uuid"}
+
+        // Retrieve the metrics.
+        metrics := c.getMetrics(s)
+
+        // Convert all gathered metrics to Prometheus Metrics and add to channel.
+        for _, m := range metrics {
+                labels := append(devLabels, m.extraLabel...)
+
+                desc := prometheus.NewDesc(
+                        prometheus.BuildFQName(namespace, subsystem, m.name),
+                        m.desc,
+                        labels,
+                        nil,
+                )
+
+                labelValues := []string{s.UUID}
+                if len(m.extraLabelValue) > 0 {
+                        labelValues = append(labelValues, m.extraLabelValue...)
+                }
+
+                ch <- prometheus.MustNewConstMetric(
+                        desc,
+                        prometheus.GaugeValue,
+                        m.value,
+                        labelValues...,
+                )
+        }
+}
+
+// getMetrics returns metrics for the given Btrfs statistics.
+func (c *btrfsCollector) getMetrics(s *btrfs.Stats) []btrfsMetric {
+        metrics := []btrfsMetric{
+                {
+                        name:            "info",
+                        desc:            "Filesystem information",
+                        value:           1,
+                        extraLabel:      []string{"label"},
+                        extraLabelValue: []string{s.Label},
+                },
+                {
+                        name:  "global_rsv_size_bytes",
+                        desc:  "Size of global reserve.",
+                        value: float64(s.Allocation.GlobalRsvSize),
+                },
+        }
+
+        // Information about devices.
+        for n, dev := range s.Devices {
+                metrics = append(metrics, btrfsMetric{
+                        name:            "device_size_bytes",
+                        desc:            "Size of a device that is part of the filesystem.",
+                        value:           float64(dev.Size),
+                        extraLabel:      []string{"device"},
+                        extraLabelValue: []string{n},
+                })
+        }
+
+        // Information about data, metadata and system data.
+        metrics = append(metrics, c.getAllocationStats("data", s.Allocation.Data)...)
+        metrics = append(metrics, c.getAllocationStats("metadata", s.Allocation.Metadata)...)
+        metrics = append(metrics, c.getAllocationStats("system", s.Allocation.System)...)
+
+        return metrics
+}
+
+// getAllocationStats returns allocation metrics for the given Btrfs Allocation statistics.
+func (c *btrfsCollector) getAllocationStats(a string, s *btrfs.AllocationStats) []btrfsMetric {
+        metrics := []btrfsMetric{
+                {
+                        name:            "reserved_bytes",
+                        desc:            "Amount of space reserved for a data type",
+                        value:           float64(s.ReservedBytes),
+                        extraLabel:      []string{"block_group_type"},
+                        extraLabelValue: []string{a},
+                },
+        }
+
+        // Add all layout statistics.
+        for layout, stats := range s.Layouts {
+                metrics = append(metrics, c.getLayoutStats(a, layout, stats)...)
+        }
+
+        return metrics
+}
+
+// getLayoutStats returns metrics for a data layout.
+func (c *btrfsCollector) getLayoutStats(a, l string, s *btrfs.LayoutUsage) []btrfsMetric {
+        return []btrfsMetric{
+                {
+                        name:            "used_bytes",
+                        desc:            "Amount of used space by a layout/data type",
+                        value:           float64(s.UsedBytes),
+                        extraLabel:      []string{"block_group_type", "mode"},
+                        extraLabelValue: []string{a, l},
+                },
+                {
+                        name:            "size_bytes",
+                        desc:            "Amount of space allocated for a layout/data type",
+                        value:           float64(s.TotalBytes),
+                        extraLabel:      []string{"block_group_type", "mode"},
+                        extraLabelValue: []string{a, l},
+                },
+                {
+                        name:            "allocation_ratio",
+                        desc:            "Data allocation ratio for a layout/data type",
+                        value:           s.Ratio,
+                        extraLabel:      []string{"block_group_type", "mode"},
+                        extraLabelValue: []string{a, l},
+                },
+        }
+}