Merge pull request #15 from sensu/feature/metrics-option

WIP: metrics output support

Author: Jef Spaleta

.github/workflows/lint.yml

@@ -13,4 +13,4 @@ jobs:
     - name: Checkout code
       uses: actions/checkout@v2
     - name: Run golangci-lint
-      uses: actions-contrib/golangci-lint@v1
+      uses: golangci/golangci-lint-action@v2

CHANGELOG.md

@@ -8,6 +8,9 @@ Versioning](http://semver.org/spec/v2.0.0.html).
 ## Unreleased
 
 ### Added
+- Added --metrics option to change output into something Sensu agent can register as tagged metrics
+- Added --metrics-format option to make tagged metrics format selectable
+- Added --tags option to make it possible to add additional tags for all metrics
 - Added --human-readable option to support ignoring human-readable option like df unix/linux command
 
 ## [0.4.2] - 2021-03-31

README.md

@@ -46,6 +46,9 @@ Flags:
   -r, --include-read-only         Include read-only filesystems (default false)
   -f, --fail-on-error             Fail and exit on errors getting file system usage (e.g. permission denied) (default false)
   -H, --human-readable            print sizes in powers of 1024 (default false)
+      --metrics                   Output metrics instead of human readable output
+      --metrics-format string     Metrics output format, supports opentsdb_line or prometheus_text (default "opentsdb_line")
+      --tags strings              Comma separated list of additional metrics tags using key=value format.
   -h, --help                      help for check-disk-usage
 
 Use "check-disk-usage [command] --help" for more information about a command.
@@ -79,6 +82,7 @@ continue to check the remaining file systems as expected.
 * The `--human-readable` (False by default) option determines if you prefer
 to display sizes of different drives in a human format. (Like df Unix/linux
 command.)
+* The `--metrics` (False by default) option will change text output to conform to selected metrics format (`--metrics-format`)
 
 ## Configuration
 

main.go

@@ -2,7 +2,9 @@ package main
 
 import (
 	"fmt"
+	"strconv"
 	"strings"
+	"time"
 
 	human "github.com/dustin/go-humanize"
 	"github.com/sensu-community/sensu-plugin-sdk/sensu"
@@ -23,10 +25,57 @@ type Config struct {
 	IncludeReadOnly bool
 	FailOnError     bool
 	HumanReadable   bool
+	MetricsMode     bool
+	ExtraTags       []string
+}
+
+type MetricGroup struct {
+	Comment string
+	Type    string
+	Name    string
+	Metrics []Metric
+}
+
+func (g *MetricGroup) AddMetric(tags map[string]string, value float64, timeNow int64) {
+	g.Metrics = append(g.Metrics, Metric{
+		Tags:      tags,
+		Timestamp: timeNow,
+		Value:     value,
+	})
+}
+func (g *MetricGroup) Output() {
+	var output string
+	metricName := strings.Replace(g.Name, ".", "_", -1)
+	fmt.Printf("# HELP %s [%s] %s\n", metricName, g.Type, g.Comment)
+	fmt.Printf("# TYPE %s %s\n", metricName, g.Type)
+	for _, m := range g.Metrics {
+		tagStr := ""
+		for tag, tvalue := range m.Tags {
+			if len(tagStr) > 0 {
+				tagStr = tagStr + ","
+			}
+			tagStr = tagStr + tag + "=\"" + tvalue + "\""
+		}
+		if len(tagStr) > 0 {
+			tagStr = "{" + tagStr + "}"
+		}
+		output = strings.Join(
+			[]string{metricName + tagStr, fmt.Sprintf("%v", m.Value), strconv.FormatInt(m.Timestamp, 10)}, " ")
+		fmt.Println(output)
+	}
+	fmt.Println("")
+}
+
+type Metric struct {
+	Tags      map[string]string
+	Timestamp int64
+	Value     float64
 }
 
 var (
-	plugin = Config{
+	tags      = map[string]string{}
+	extraTags = map[string]string{}
+	plugin    = Config{
 		PluginConfig: sensu.PluginConfig{
 			Name:     "check-disk-usage",
 			Short:    "Cross platform disk usage check for Sensu",
@@ -125,6 +174,22 @@ var (
 			Usage:     "print sizes in powers of 1024 (default false)",
 			Value:     &plugin.HumanReadable,
 		},
+		{
+			Path:     "metrics",
+			Env:      "",
+			Argument: "metrics",
+			Default:  false,
+			Usage:    "Output metrics instead of human readable output",
+			Value:    &plugin.MetricsMode,
+		},
+		{
+			Path:     "tags",
+			Env:      "",
+			Argument: "tags",
+			Default:  []string{},
+			Usage:    "Comma separated list of additional metrics tags using key=value format.",
+			Value:    &plugin.ExtraTags,
+		},
 	}
 )
 
@@ -143,6 +208,15 @@ func checkArgs(event *types.Event) (int, error) {
 	if plugin.Warning >= plugin.Critical {
 		return sensu.CheckStateCritical, fmt.Errorf("--warning value can not be greater than or equal to --critical value")
 	}
+	for _, tagString := range plugin.ExtraTags {
+		fmt.Println(tagString)
+		parts := strings.Split(tagString, `=`)
+		if len(parts) == 2 {
+			extraTags[parts[0]] = parts[1]
+		} else {
+			return sensu.CheckStateCritical, fmt.Errorf("Failed to parse input tag: %s", tagString)
+		}
+	}
 	return sensu.CheckStateOK, nil
 }
 
@@ -152,12 +226,56 @@ func executeCheck(event *types.Event) (int, error) {
 		warnings  int
 	)
 
+	timeNow := time.Now().Unix()
 	parts, err := disk.Partitions(plugin.IncludePseudo)
 	if err != nil {
 		return sensu.CheckStateCritical, fmt.Errorf("Failed to get partitions, error: %v", err)
 	}
 
+	metricGroups := map[string]*MetricGroup{
+		"disk.critical": &MetricGroup{
+			Name:    "disk.critical",
+			Type:    "GAUGE",
+			Comment: "non-zero value indicates mountpoint usage is above critical threshold",
+			Metrics: []Metric{},
+		},
+		"disk.warning": &MetricGroup{
+			Name:    "disk.warning",
+			Type:    "GAUGE",
+			Comment: "non-zero value indicates mountpoint usage is above warning threshold",
+			Metrics: []Metric{},
+		},
+		"disk.percent_used": &MetricGroup{
+			Name:    "disk.percent_usage",
+			Type:    "GAUGE",
+			Comment: "Percentage of mounted volume used",
+			Metrics: []Metric{},
+		},
+		"disk.total_bytes": &MetricGroup{
+			Name:    "disk.total_bytes",
+			Type:    "GAUGE",
+			Comment: "Total size in bytes of mounted volumed",
+			Metrics: []Metric{},
+		},
+		"disk.used_bytes": &MetricGroup{
+			Name:    "disk.used_bytes",
+			Type:    "GAUGE",
+			Comment: "Used size in bytes of mounted volumed",
+			Metrics: []Metric{},
+		},
+		"disk.free_bytes": &MetricGroup{
+			Name:    "disk.free_bytes",
+			Type:    "GAUGE",
+			Comment: "Free size in bytes of mounted volumed",
+			Metrics: []Metric{},
+		},
+	}
+
 	for _, p := range parts {
+		tags = map[string]string{}
+		for key, value := range extraTags {
+			tags[key] = value
+		}
 		// Ignore excluded (or non-included) file system types
 		if !isValidFSType(p.Fstype) {
 			continue
@@ -173,13 +291,16 @@ func executeCheck(event *types.Event) (int, error) {
 			continue
 		}
 
+		tags["mountpoint"] = p.Mountpoint
 		device := p.Mountpoint
 		s, err := disk.Usage(device)
 		if err != nil {
 			if plugin.FailOnError {
 				return sensu.CheckStateCritical, fmt.Errorf("Failed to get disk usage for %s, error: %v", device, err)
 			}
-			fmt.Printf("%s  UNKNOWN: %s - error: %v\n", plugin.PluginConfig.Name, device, err)
+			if !plugin.MetricsMode {
+				fmt.Printf("%s  UNKNOWN: %s - error: %v\n", plugin.PluginConfig.Name, device, err)
+			}
 			continue
 		}
 
@@ -189,23 +310,67 @@ func executeCheck(event *types.Event) (int, error) {
 		}
 
 		// implement magic factor for larger file systems?
-		fmt.Printf("%s ", plugin.PluginConfig.Name)
+		crit := 0
+		warn := 0
 		if s.UsedPercent >= plugin.Critical {
 			criticals++
-			fmt.Printf("CRITICAL: ")
-		} else if s.UsedPercent >= plugin.Warning {
+			crit = 1
+		}
+		if s.UsedPercent >= plugin.Warning {
 			warnings++
-			fmt.Printf(" WARNING: ")
+			warn = 1
+		}
+		metricGroups["disk.critical"].AddMetric(tags, float64(crit), timeNow)
+		metricGroups["disk.warning"].AddMetric(tags, float64(warn), timeNow)
+		if !plugin.MetricsMode {
+			fmt.Printf("%s ", plugin.PluginConfig.Name)
+			if crit > 0 {
+				fmt.Printf("CRITICAL: ")
+			} else if warn > 0 {
+				fmt.Printf(" WARNING: ")
+			} else {
+				fmt.Printf("      OK: ")
+			}
+			if plugin.HumanReadable {
+				fmt.Printf("%s %.2f%% - Total: %s, Used: %s, Free: %s\n",
+					p.Mountpoint, s.UsedPercent, human.IBytes(s.Total), human.IBytes(s.Used), human.IBytes(s.Free))
+			} else {
+				fmt.Printf("%s %.2f%% - Total: %s, Used: %s, Free: %s\n",
+					p.Mountpoint, s.UsedPercent, human.Bytes(s.Total), human.Bytes(s.Used), human.Bytes(s.Free))
+			}
+		}
+		metricGroups["disk.percent_used"].AddMetric(tags, float64(s.UsedPercent), timeNow)
+		metricGroups["disk.total_bytes"].AddMetric(tags, float64(s.Total), timeNow)
+		metricGroups["disk.used_bytes"].AddMetric(tags, float64(s.Used), timeNow)
+		metricGroups["disk.free_bytes"].AddMetric(tags, float64(s.Free), timeNow)
+	}
+	tags = map[string]string{}
+	for key, value := range extraTags {
+		tags[key] = value
+	}
+	tags["mountpoint"] = "any"
+	anyCritical := func() float64 {
+		if criticals > 0 {
+			return 1
 		} else {
-			fmt.Printf("      OK: ")
+			return 0
 		}
-		if plugin.HumanReadable {
-			fmt.Printf("%s %.2f%% - Total: %s, Used: %s, Free: %s\n", p.Mountpoint, s.UsedPercent, human.IBytes(s.Total), human.IBytes(s.Used), human.IBytes(s.Free))
+	}()
+	metricGroups["disk.critical"].AddMetric(tags, anyCritical, timeNow)
+	anyWarning := func() float64 {
+		if warnings > 0 {
+			return 1
 		} else {
-			fmt.Printf("%s %.2f%% - Total: %s, Used: %s, Free: %s\n", p.Mountpoint, s.UsedPercent, human.Bytes(s.Total), human.Bytes(s.Used), human.Bytes(s.Free))
+			return 0
+		}
+	}()
+	metricGroups["disk.warning"].AddMetric(tags, anyWarning, timeNow)
+	if plugin.MetricsMode {
+		for _, g := range metricGroups {
+			g.Output()
 		}
-	}
 
+	}
 	if criticals > 0 {
 		return sensu.CheckStateCritical, nil
 	} else if warnings > 0 {