dmcache_linux.go

// +build linux

package dmcache

import (
	"errors"
	"fmt"
	"os/exec"
	"strconv"
	"strings"

	"github.com/circonus-labs/circonus-unified-agent/cua"
)

const metricName = "dmcache"

type cacheStatus struct {
	device            string
	length            int64
	target            string
	metadataBlocksize int64
	metadataUsed      int64
	metadataTotal     int64
	cacheBlocksize    int64
	cacheUsed         int64
	cacheTotal        int64
	readHits          int64
	readMisses        int64
	writeHits         int64
	writeMisses       int64
	demotions         int64
	promotions        int64
	dirty             int64
}

func (c *DMCache) Gather(acc cua.Accumulator) error {
	outputLines, err := c.getCurrentStatus()
	if err != nil {
		return err
	}

	totalStatus := cacheStatus{}

	for _, s := range outputLines {
		status, err := parseDMSetupStatus(s)
		if err != nil {
			return err
		}

		if c.PerDevice {
			tags := map[string]string{"device": status.device}
			acc.AddFields(metricName, toFields(status), tags)
		}
		aggregateStats(&totalStatus, status)
	}

	acc.AddFields(metricName, toFields(totalStatus), map[string]string{"device": "all"})

	return nil
}

func parseDMSetupStatus(line string) (cacheStatus, error) {
	var err error
	parseError := errors.New("Output from dmsetup could not be parsed")
	status := cacheStatus{}
	values := strings.Fields(line)
	if len(values) < 15 {
		return cacheStatus{}, parseError
	}

	status.device = strings.TrimRight(values[0], ":")
	status.length, err = strconv.ParseInt(values[2], 10, 64)
	if err != nil {
		return cacheStatus{}, fmt.Errorf("dmcache parseint len (%s): %w", values[2], err)
	}
	status.target = values[3]
	status.metadataBlocksize, err = strconv.ParseInt(values[4], 10, 64)
	if err != nil {
		return cacheStatus{}, fmt.Errorf("dmcache parseint blksz (%s): %w", values[4], err)
	}
	metadata := strings.Split(values[5], "/")
	if len(metadata) != 2 {
		return cacheStatus{}, parseError
	}
	status.metadataUsed, err = strconv.ParseInt(metadata[0], 10, 64)
	if err != nil {
		return cacheStatus{}, fmt.Errorf("dmcache parseint metaused (%s): %w", metadata[0], err)
	}
	status.metadataTotal, err = strconv.ParseInt(metadata[1], 10, 64)
	if err != nil {
		return cacheStatus{}, fmt.Errorf("dmcache parseint metatot (%s): %w", metadata[1], err)
	}
	status.cacheBlocksize, err = strconv.ParseInt(values[6], 10, 64)
	if err != nil {
		return cacheStatus{}, fmt.Errorf("dmcache parseint cacheblksz (%s): %w", values[6], err)
	}
	cache := strings.Split(values[7], "/")
	if len(cache) != 2 {
		return cacheStatus{}, parseError
	}
	status.cacheUsed, err = strconv.ParseInt(cache[0], 10, 64)
	if err != nil {
		return cacheStatus{}, fmt.Errorf("dmcache parseint cacheused (%s): %w", cache[0], err)
	}
	status.cacheTotal, err = strconv.ParseInt(cache[1], 10, 64)
	if err != nil {
		return cacheStatus{}, fmt.Errorf("dmcache parseint cachetot (%s): %w", cache[1], err)
	}
	status.readHits, err = strconv.ParseInt(values[8], 10, 64)
	if err != nil {
		return cacheStatus{}, fmt.Errorf("dmcache parseint rhit (%s): %w", values[8], err)
	}
	status.readMisses, err = strconv.ParseInt(values[9], 10, 64)
	if err != nil {
		return cacheStatus{}, fmt.Errorf("dmcache parseint rmiss (%s): %w", values[9], err)
	}
	status.writeHits, err = strconv.ParseInt(values[10], 10, 64)
	if err != nil {
		return cacheStatus{}, fmt.Errorf("dmcache parseint whit (%s): %w", values[10], err)
	}
	status.writeMisses, err = strconv.ParseInt(values[11], 10, 64)
	if err != nil {
		return cacheStatus{}, fmt.Errorf("dmcache parseint wmiss (%s): %w", values[11], err)
	}
	status.demotions, err = strconv.ParseInt(values[12], 10, 64)
	if err != nil {
		return cacheStatus{}, fmt.Errorf("dmcache parseint demotions (%s): %w", values[12], err)
	}
	status.promotions, err = strconv.ParseInt(values[13], 10, 64)
	if err != nil {
		return cacheStatus{}, fmt.Errorf("dmcache parseint promotions (%s): %w", values[13], err)
	}
	status.dirty, err = strconv.ParseInt(values[14], 10, 64)
	if err != nil {
		return cacheStatus{}, fmt.Errorf("dmcache parseint dirty (%s): %w", values[14], err)
	}

	return status, nil
}

func aggregateStats(totalStatus *cacheStatus, status cacheStatus) {
	totalStatus.length += status.length
	totalStatus.metadataBlocksize += status.metadataBlocksize
	totalStatus.metadataUsed += status.metadataUsed
	totalStatus.metadataTotal += status.metadataTotal
	totalStatus.cacheBlocksize += status.cacheBlocksize
	totalStatus.cacheUsed += status.cacheUsed
	totalStatus.cacheTotal += status.cacheTotal
	totalStatus.readHits += status.readHits
	totalStatus.readMisses += status.readMisses
	totalStatus.writeHits += status.writeHits
	totalStatus.writeMisses += status.writeMisses
	totalStatus.demotions += status.demotions
	totalStatus.promotions += status.promotions
	totalStatus.dirty += status.dirty
}

func toFields(status cacheStatus) map[string]interface{} {
	fields := make(map[string]interface{})
	fields["length"] = status.length
	fields["metadata_blocksize"] = status.metadataBlocksize
	fields["metadata_used"] = status.metadataUsed
	fields["metadata_total"] = status.metadataTotal
	fields["cache_blocksize"] = status.cacheBlocksize
	fields["cache_used"] = status.cacheUsed
	fields["cache_total"] = status.cacheTotal
	fields["read_hits"] = status.readHits
	fields["read_misses"] = status.readMisses
	fields["write_hits"] = status.writeHits
	fields["write_misses"] = status.writeMisses
	fields["demotions"] = status.demotions
	fields["promotions"] = status.promotions
	fields["dirty"] = status.dirty
	return fields
}

func dmSetupStatus() ([]string, error) {
	out, err := exec.Command("/bin/sh", "-c", "sudo /sbin/dmsetup status --target cache").Output()
	if err != nil {
		return nil, fmt.Errorf("dmcache exec: %w", err)
	}
	if string(out) == "No devices found\n" {
		return []string{}, nil
	}

	outString := strings.TrimRight(string(out), "\n")
	status := strings.Split(outString, "\n")

	return status, nil
}