feat: /proc/mdstat collection

plugins/inputs/all/all.go

@@ -99,6 +99,7 @@ import (
 	_ "github.com/influxdata/telegraf/plugins/inputs/mailchimp"
 	_ "github.com/influxdata/telegraf/plugins/inputs/marklogic"
 	_ "github.com/influxdata/telegraf/plugins/inputs/mcrouter"
+	_ "github.com/influxdata/telegraf/plugins/inputs/mdstat"
 	_ "github.com/influxdata/telegraf/plugins/inputs/mem"
 	_ "github.com/influxdata/telegraf/plugins/inputs/memcached"
 	_ "github.com/influxdata/telegraf/plugins/inputs/mesos"

plugins/inputs/mdstat/README.md

@@ -0,0 +1,45 @@
+# mdstat Input Plugin
+
+The mdstat plugin gathers statistics about any Linux MD RAID arrays configured on the host
+by reading /proc/mdstat. For a full list of available fields see the 
+/proc/mdstat section of the [proc man page](http://man7.org/linux/man-pages/man5/proc.5.html).
+For a better idea of what each field represents, see the 
+[mdstat man page](https://raid.wiki.kernel.org/index.php/Mdstat).
+
+
+### Configuration:
+
+```toml
+# Get kernel statistics from /proc/vmstat
+[[inputs.mdstat]]
+  # no configuration
+```
+
+### Measurements & Fields:
+
+- mdstat
+  - BlocksSynced (if the array is rebuilding/checking, this is the count of blocks that have been scanned)
+  - BlocksSyncedFinishTime (the expected finish time of the rebuild scan, listed in minutes remaining)
+  - BlocksSyncedPct (the percentage of the rebuild scan left)
+  - BlocksSyncedSpeed (the current speed the rebuild is running at, listed in K/sec)
+  - BlocksTotal (the total count of blocks in the array)
+  - DisksActive (the number of disks that are currently considered healthy in the array)
+  - DisksFailed (the current count of failed disks in the array)
+  - DisksSpare (the current count of "spare" disks in the array)
+  - DisksTotal (total count of disks in the array)
+
+### Tags:
+
+- mdstat
+  - ActivityState (`active` or `inactive`)
+  - Devices (comma separated list of devices that make up the array)
+  - Name (name of the array)
+
+### Example Output:
+
+```
+$ telegraf --config ~/ws/telegraf.conf --input-filter mdstat --test
+* Plugin: kernel_vmstat, Collection 1
+> mdstat,ActivityState=active,Devices=sdm1\,sdn1,Name=md1 BlocksSynced=231299072i,BlocksSyncedFinishTime=0,BlocksSyncedPct=0,BlocksSyncedSpeed=0,BlocksTotal=231299072i,DisksActive=2i,DisksFailed=0i,DisksSpare=0i,DisksTotal=2i 1617814276000000000
+> mdstat,ActivityState=active,Devices=sdm5\,sdn5,Name=md2 BlocksSynced=2996224i,BlocksSyncedFinishTime=0,BlocksSyncedPct=0,BlocksSyncedSpeed=0,BlocksTotal=2996224i,DisksActive=2i,DisksFailed=0i,DisksSpare=0i,DisksTotal=2i 1617814276000000000
+```

plugins/inputs/mdstat/mdstat.go

@@ -0,0 +1,262 @@
+// +build linux
+
+// Copyright 2018 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.
+//
+// Code has been changed since initial import.
+
+package mdstat
+
+import (
+	"fmt"
+	"io/ioutil"
+	"os"
+	"regexp"
+	"sort"
+	"strconv"
+	"strings"
+
+	"github.com/influxdata/telegraf"
+	"github.com/influxdata/telegraf/plugins/inputs"
+)
+
+var (
+	statusLineRE         = regexp.MustCompile(`(\d+) blocks .*\[(\d+)/(\d+)\] \[[U_]+\]`)
+	recoveryLineBlocksRE = regexp.MustCompile(`\((\d+)/\d+\)`)
+	recoveryLinePctRE    = regexp.MustCompile(`= (.+)%`)
+	recoveryLineFinishRE = regexp.MustCompile(`finish=(.+)min`)
+	recoveryLineSpeedRE  = regexp.MustCompile(`speed=(.+)[A-Z]`)
+	componentDeviceRE    = regexp.MustCompile(`(.*)\[\d+\]`)
+)
+
+type MdstatConf struct {
+	statFile string
+}
+
+func (k *MdstatConf) Description() string {
+	return "Get md array statistics from /proc/mdstat"
+}
+
+var mdSampleConfig = `
+	## No configuration required for this collector
+`
+
+func (k *MdstatConf) SampleConfig() string {
+	return mdSampleConfig
+}
+
+func evalStatusLine(deviceLine, statusLine string) (active, total, size int64, err error) {
+	sizeFields := strings.Fields(statusLine)
+	if len(sizeFields) < 1 {
+		return 0, 0, 0, fmt.Errorf("statusLine empty? %q: %w", statusLine, err)
+	}
+	sizeStr := sizeFields[0]
+	size, err = strconv.ParseInt(sizeStr, 10, 64)
+	if err != nil {
+		return 0, 0, 0, fmt.Errorf("unexpected statusLine %q: %w", statusLine, err)
+	}
+
+	if strings.Contains(deviceLine, "raid0") || strings.Contains(deviceLine, "linear") {
+		// In the device deviceLine, only disks have a number associated with them in [].
+		total = int64(strings.Count(deviceLine, "["))
+		return total, total, size, nil
+	}
+
+	if strings.Contains(deviceLine, "inactive") {
+		return 0, 0, size, nil
+	}
+
+	matches := statusLineRE.FindStringSubmatch(statusLine)
+	if len(matches) != 4 {
+		return 0, 0, 0, fmt.Errorf("couldn't find all the substring matches: %s", statusLine)
+	}
+
+	total, err = strconv.ParseInt(matches[2], 10, 64)
+	if err != nil {
+		return 0, 0, 0, fmt.Errorf("unexpected statusLine %q: %w", statusLine, err)
+	}
+
+	active, err = strconv.ParseInt(matches[3], 10, 64)
+	if err != nil {
+		return 0, 0, 0, fmt.Errorf("unexpected statusLine %q: %w", statusLine, err)
+	}
+
+	return active, total, size, nil
+}
+
+func evalRecoveryLine(recoveryLine string) (syncedBlocks int64, pct float64, finish float64, speed float64, err error) {
+	// Get count of completed vs. total blocks
+	matches := recoveryLineBlocksRE.FindStringSubmatch(recoveryLine)
+	if len(matches) != 2 {
+		return 0, 0, 0, 0, fmt.Errorf("unexpected recoveryLine matching syncedBlocks: %s", recoveryLine)
+	}
+	syncedBlocks, err = strconv.ParseInt(matches[1], 10, 64)
+	if err != nil {
+		return 0, 0, 0, 0, fmt.Errorf("error parsing int from recoveryLine %q: %w", recoveryLine, err)
+	}
+
+	// Get percentage complete
+	matches = recoveryLinePctRE.FindStringSubmatch(recoveryLine)
+	if len(matches) != 2 {
+		return 0, 0, 0, 0, fmt.Errorf("unexpected recoveryLine matching percentage: %s", recoveryLine)
+	}
+	pct, err = strconv.ParseFloat(matches[1], 64)
+	if err != nil {
+		return 0, 0, 0, 0, fmt.Errorf("error parsing float from recoveryLine %q: %w", recoveryLine, err)
+	}
+
+	// Get time expected left to complete
+	matches = recoveryLineFinishRE.FindStringSubmatch(recoveryLine)
+	if len(matches) != 2 {
+		return 0, 0, 0, 0, fmt.Errorf("unexpected recoveryLine matching est. finish time: %s", recoveryLine)
+	}
+	finish, err = strconv.ParseFloat(matches[1], 64)
+	if err != nil {
+		return 0, 0, 0, 0, fmt.Errorf("error parsing float from recoveryLine %q: %w", recoveryLine, err)
+	}
+
+	// Get recovery speed
+	matches = recoveryLineSpeedRE.FindStringSubmatch(recoveryLine)
+	if len(matches) != 2 {
+		return 0, 0, 0, 0, fmt.Errorf("unexpected recoveryLine matching speed: %s", recoveryLine)
+	}
+	speed, err = strconv.ParseFloat(matches[1], 64)
+	if err != nil {
+		return 0, 0, 0, 0, fmt.Errorf("error parsing float from recoveryLine %q: %w", recoveryLine, err)
+	}
+
+	return syncedBlocks, pct, finish, speed, nil
+}
+
+func evalComponentDevices(deviceFields []string) string {
+	mdComponentDevices := make([]string, 0)
+	if len(deviceFields) > 3 {
+		for _, field := range deviceFields[4:] {
+			match := componentDeviceRE.FindStringSubmatch(field)
+			if match == nil {
+				continue
+			}
+			mdComponentDevices = append(mdComponentDevices, match[1])
+		}
+	}
+
+	// Ensure no churn on tag ordering change
+	sort.Strings(mdComponentDevices)
+	return strings.Join(mdComponentDevices, ",")
+}
+
+func (k *MdstatConf) Gather(acc telegraf.Accumulator) error {
+	data, err := k.getProcMdstat()
+	if err != nil {
+		return err
+	}
+	lines := strings.Split(string(data), "\n")
+	for i, line := range lines {
+		if strings.TrimSpace(line) == "" || line[0] == ' ' || strings.HasPrefix(line, "Personalities") || strings.HasPrefix(line, "unused") {
+			continue
+		}
+		deviceFields := strings.Fields(line)
+		if len(deviceFields) < 3 || len(lines) <= i+3 {
+			return fmt.Errorf("not enough fields in mdline (expected at least 3): %s", line)
+		}
+		mdName := deviceFields[0] // mdx
+		state := deviceFields[2]  // active or inactive
+
+		// Failed disks have the suffix (F) & Spare disks have the suffix (S).
+		fail := int64(strings.Count(line, "(F)"))
+		spare := int64(strings.Count(line, "(S)"))
+
+		active, total, size, err := evalStatusLine(lines[i], lines[i+1])
+		if err != nil {
+			return fmt.Errorf("error parsing md device lines: %w", err)
+		}
+
+		syncLineIdx := i + 2
+		if strings.Contains(lines[i+2], "bitmap") { // skip bitmap line
+			syncLineIdx++
+		}
+
+		// If device is syncing at the moment, get the number of currently
+		// synced bytes, otherwise that number equals the size of the device.
+		syncedBlocks := size
+		speed := float64(0)
+		finish := float64(0)
+		pct := float64(0)
+		recovering := strings.Contains(lines[syncLineIdx], "recovery")
+		resyncing := strings.Contains(lines[syncLineIdx], "resync")
+		checking := strings.Contains(lines[syncLineIdx], "check")
+
+		// Append recovery and resyncing state info.
+		if recovering || resyncing || checking {
+			if recovering {
+				state = "recovering"
+			} else if checking {
+				state = "checking"
+			} else {
+				state = "resyncing"
+			}
+
+			// Handle case when resync=PENDING or resync=DELAYED.
+			if strings.Contains(lines[syncLineIdx], "PENDING") || strings.Contains(lines[syncLineIdx], "DELAYED") {
+				syncedBlocks = 0
+			} else {
+				syncedBlocks, pct, finish, speed, err = evalRecoveryLine(lines[syncLineIdx])
+				if err != nil {
+					return fmt.Errorf("error parsing sync line in md device %q: %w", mdName, err)
+				}
+			}
+		}
+		fields := map[string]interface{}{
+			"DisksActive":            active,
+			"DisksFailed":            fail,
+			"DisksSpare":             spare,
+			"DisksTotal":             total,
+			"BlocksTotal":            size,
+			"BlocksSynced":           syncedBlocks,
+			"BlocksSyncedPct":        pct,
+			"BlocksSyncedFinishTime": finish,
+			"BlocksSyncedSpeed":      speed,
+		}
+		tags := map[string]string{
+			"Name":          mdName,
+			"ActivityState": state,
+			"Devices":       evalComponentDevices(deviceFields),
+		}
+		acc.AddFields("mdstat", fields, tags)
+	}
+
+	return nil
+}
+
+func (k *MdstatConf) getProcMdstat() ([]byte, error) {
+	if _, err := os.Stat(k.statFile); os.IsNotExist(err) {
+		return nil, fmt.Errorf("mdstat: %s does not exist", k.statFile)
+	} else if err != nil {
+		return nil, err
+	}
+
+	data, err := ioutil.ReadFile(k.statFile)
+	if err != nil {
+		return nil, err
+	}
+
+	return data, nil
+}
+
+func init() {
+	inputs.Add("mdstat", func() telegraf.Input {
+		return &MdstatConf{
+			statFile: "/proc/mdstat",
+		}
+	})
+}

plugins/inputs/mdstat/mdstat_notlinux.go

@@ -0,0 +1,3 @@
+// +build !linux
+
+package mdstat